Changeset 142921 in webkit

Timestamp:

Feb 14, 2013 2:31:20 PM (11 years ago)

Author:

mark.lam@apple.com

Message:

Split SQLTransaction work between the frontend and backend.
​https://bugs.webkit.org/show_bug.cgi?id=104750.

Reviewed by Sam Weinig.

This is part of the webdatabase refactoring for webkit2.

1. Changed how transactions are created.

• Database::runTransaction() first creates a SQLTransaction frontend which encapsulates the 3 script callbacks. It then passes the SQLTransaction to the backend database to create the SQLTransactionBackend.
• The SQLTransactionBackend manages all SQLiteTransaction work.

2. Introduced SQLTransactionState and SQLTransactionStateMachine.

• Instead of tracking the transaction phases as "steps" in m_nextStep, we now use m_nextState which is of enum class SQLTransactionState. Unlike m_nextStep which is a pointer to a "step" function, m_nextState is a state variable which is used to index into a state dispatch table.

• Both SQLTransaction and SQLTransactionBackend now extends SQLTransactionStateMachine, and uses its dispatch mechanism based on the SQLTransactionState.

• Instead of having 1 state machine instances, there are 2: 1 in the frontend, and 1 in the backend. The 2 have mirrored states, and transfers work to the other state machine when needed.

• Previously, state functions can be called inline from other states. They are now only called from the state machines runStateMachine() method. This makes it possible to isolate the state transition mechanism going between the sides (frontend and backend) to 2 functions only: SQLTransaction::sendToBackendState() and SQLTransactionBackend::sendToFrontendState().

3. Consolidated cleanup work (mostly) to a unified cleanup function.

4. Changed the frontend Database::runTransaction() to use a ChangeVersionData* (instead of a ChangeVersionWrapper ref ptr).

• This is necessary because ChangeVersionWrapper contains functionality used in processing a transaction (to be invoked in the backend). Instead, what we want is to simply pass the 2 old and new version strings to the backend. The new ChangeVersionData simply packages up these 2 strings.
• This makes ChangeVersionData easy to serialize for IPC messaging later.

5. Moved some transaction functions back to the frontend SQLTransaction because they belong there.

6. Moved some Database functions to its DatabaseBackendAsync backend now that the transaction has been split up.

• This is driven naturally by those functions being used exclusively in the backend for transaction work.
• SQLTransactionClient, SQLTransactionCoordinator, and SQLTransactionWrapper are now exclusively backend data structures. SQLTransactionClient still has some frontend "pollution" that I'll fix later.

7. Made the few database report functions used only by Chromium conditional on PLATFORM(chromium).

• The report functions gets re-routed to Chromium's DatabaseObserver which further routes them elsewhere. It is unclear how Chromium uses these routed messages, and I am therefore not able to determine how they should work in a frontend/backend world. So, I'm #ifdef'ing them out. They still work like in the old way for Chromium.

8. Added new files to the build / project files.

9. Updated / added comments about how the transaction and its states work.

No new tests.

• CMakeLists.txt:
• GNUmakefile.list.am:
• Modules/webdatabase/AbstractDatabaseServer.h:
• Modules/webdatabase/ChangeVersionData.h: Added.

(ChangeVersionData):
(WebCore::ChangeVersionData::ChangeVersionData):
(WebCore::ChangeVersionData::oldVersion):
(WebCore::ChangeVersionData::newVersion):

• Modules/webdatabase/ChangeVersionWrapper.cpp:

(WebCore::ChangeVersionWrapper::performPreflight):
(WebCore::ChangeVersionWrapper::performPostflight):
(WebCore::ChangeVersionWrapper::handleCommitFailedAfterPostflight):

• Modules/webdatabase/ChangeVersionWrapper.h:

(ChangeVersionWrapper):

• Modules/webdatabase/Database.cpp:

(WebCore::Database::Database):
(WebCore::Database::close):
(WebCore::Database::changeVersion):
(WebCore::Database::transaction):
(WebCore::Database::readTransaction):
(WebCore::Database::runTransaction):
(WebCore::Database::reportStartTransactionResult):
(WebCore::Database::reportCommitTransactionResult):
(WebCore::Database::reportExecuteStatementResult):

• Modules/webdatabase/Database.h:

(WebCore::Database::databaseContext):
(Database):
(WebCore::Database::reportStartTransactionResult):
(WebCore::Database::reportCommitTransactionResult):
(WebCore::Database::reportExecuteStatementResult):

• Modules/webdatabase/DatabaseBackend.cpp:
• Modules/webdatabase/DatabaseBackend.h:

(DatabaseBackend):
(WebCore::DatabaseBackend::reportOpenDatabaseResult):
(WebCore::DatabaseBackend::reportChangeVersionResult):
(WebCore::DatabaseBackend::reportStartTransactionResult):
(WebCore::DatabaseBackend::reportCommitTransactionResult):
(WebCore::DatabaseBackend::reportExecuteStatementResult):
(WebCore::DatabaseBackend::reportVacuumDatabaseResult):

• Modules/webdatabase/DatabaseBackendAsync.cpp:

(WebCore::DatabaseBackendAsync::DatabaseBackendAsync):
(WebCore::DatabaseBackendAsync::runTransaction):
(WebCore::DatabaseBackendAsync::inProgressTransactionCompleted): Moved from frontend.
(WebCore::DatabaseBackendAsync::scheduleTransaction): Moved from frontend.
(WebCore::DatabaseBackendAsync::scheduleTransactionStep): Moved from frontend.
(WebCore::DatabaseBackendAsync::transactionClient): Moved from frontend.
(WebCore::DatabaseBackendAsync::transactionCoordinator): Moved from frontend.

• Modules/webdatabase/DatabaseBackendAsync.h:

(DatabaseBackendAsync):

• Modules/webdatabase/DatabaseBackendContext.cpp:

(WebCore::DatabaseBackendContext::frontend):

• Modules/webdatabase/DatabaseBackendContext.h:

(DatabaseBackendContext):

• Modules/webdatabase/DatabaseManager.cpp:
• Modules/webdatabase/DatabaseManager.h:

(DatabaseManager):

• Modules/webdatabase/DatabaseServer.cpp:
• Modules/webdatabase/DatabaseServer.h:
• Modules/webdatabase/DatabaseTask.cpp:

(WebCore::DatabaseBackendAsync::DatabaseTransactionTask::doPerformTask):

• Modules/webdatabase/SQLTransaction.cpp:

(WebCore::SQLTransaction::create):
(WebCore::SQLTransaction::SQLTransaction):
(WebCore::SQLTransaction::setBackend):
(WebCore::SQLTransaction::stateFunctionFor):
(WebCore::SQLTransaction::requestTransitToState):
(WebCore::SQLTransaction::nextStateForTransactionError):

• was handleTransactionError(). There's also a backend version.

(WebCore::SQLTransaction::deliverTransactionCallback): Moved from backend.
(WebCore::SQLTransaction::deliverTransactionErrorCallback): Moved from backend.
(WebCore::SQLTransaction::deliverStatementCallback): Moved from backend.
(WebCore::SQLTransaction::deliverQuotaIncreaseCallback): Moved from backend.
(WebCore::SQLTransaction::deliverSuccessCallback): Moved from backend.
(WebCore::SQLTransaction::unreachableState):
(WebCore::SQLTransaction::sendToBackendState):
(WebCore::SQLTransaction::performPendingCallback): Moved from backend.
(WebCore::SQLTransaction::executeSQL): Moved from backend.
(WebCore::SQLTransaction::checkAndHandleClosedOrInterruptedDatabase):
(WebCore::SQLTransaction::clearCallbackWrappers):

• Modules/webdatabase/SQLTransaction.h:

(SQLTransaction):
(WebCore::SQLTransaction::database):
(WebCore::SQLTransaction::hasCallback):
(WebCore::SQLTransaction::hasSuccessCallback):
(WebCore::SQLTransaction::hasErrorCallback):

• Modules/webdatabase/SQLTransactionBackend.cpp:

(WebCore::SQLTransactionBackend::create):
(WebCore::SQLTransactionBackend::SQLTransactionBackend):
(WebCore::SQLTransactionBackend::doCleanup):
(WebCore::SQLTransactionBackend::transactionError):
(WebCore::SQLTransactionBackend::setShouldRetryCurrentStatement):
(WebCore::SQLTransactionBackend::stateFunctionFor):
(WebCore::SQLTransactionBackend::enqueueStatement):
(WebCore::SQLTransactionBackend::checkAndHandleClosedOrInterruptedDatabase):
(WebCore::SQLTransactionBackend::performNextStep):
(WebCore::SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown):
(WebCore::SQLTransactionBackend::acquireLock):
(WebCore::SQLTransactionBackend::lockAcquired):
(WebCore::SQLTransactionBackend::openTransactionAndPreflight):
(WebCore::SQLTransactionBackend::runStatements):
(WebCore::SQLTransactionBackend::runCurrentStatementAndGetNextState):

• was runCurrentStatement().

(WebCore::SQLTransactionBackend::nextStateForCurrentStatementError):

• was handleCurrentStatementError().

(WebCore::SQLTransactionBackend::postflightAndCommit):
(WebCore::SQLTransactionBackend::cleanupAndTerminate):
(WebCore::SQLTransactionBackend::nextStateForTransactionError):

• was handleTransactionError(). There's also a frontend version.

(WebCore::SQLTransactionBackend::cleanupAfterTransactionErrorCallback):
(WebCore::SQLTransactionBackend::requestTransitToState):
(WebCore::SQLTransactionBackend::unreachableState):
(WebCore::SQLTransactionBackend::sendToFrontendState):

• Modules/webdatabase/SQLTransactionBackend.h:

(SQLTransactionWrapper):
(SQLTransactionBackend):
(WebCore::SQLTransactionBackend::database):

• Modules/webdatabase/SQLTransactionClient.cpp:

(WebCore::SQLTransactionClient::didCommitWriteTransaction):
(WebCore::SQLTransactionClient::didExecuteStatement):

• Modules/webdatabase/SQLTransactionCoordinator.cpp:

(WebCore::getDatabaseIdentifier):

• Modules/webdatabase/SQLTransactionState.h: Added.
• Modules/webdatabase/SQLTransactionStateMachine.cpp: Added.

(WebCore::nameForSQLTransactionState):

• was debugStepName().

• Modules/webdatabase/SQLTransactionStateMachine.h: Added.

(SQLTransactionStateMachine):
(WebCore::SQLTransactionStateMachine::~SQLTransactionStateMachine):
(WebCore::::SQLTransactionStateMachine):
(WebCore::::setStateToRequestedState):
(WebCore::::runStateMachine):

• Target.pri:
• WebCore.gypi:
• WebCore.vcproj/WebCore.vcproj:
• WebCore.vcxproj/WebCore.vcxproj:
• WebCore.vcxproj/WebCore.vcxproj.filters:
• WebCore.xcodeproj/project.pbxproj:
• inspector/InspectorDatabaseAgent.cpp:

Location:

trunk/Source/WebCore

Files:

• CMakeLists.txt (modified) (1 diff)
• ChangeLog (modified) (1 diff)
• GNUmakefile.list.am (modified) (2 diffs)
• Modules/webdatabase/AbstractDatabaseServer.h (modified) (1 diff)
• Modules/webdatabase/ChangeVersionData.h (added)
• Modules/webdatabase/ChangeVersionWrapper.cpp (modified) (4 diffs)
• Modules/webdatabase/ChangeVersionWrapper.h (modified) (3 diffs)
• Modules/webdatabase/Database.cpp (modified) (9 diffs)
• Modules/webdatabase/Database.h (modified) (5 diffs)
• Modules/webdatabase/DatabaseBackend.cpp (modified) (1 diff)
• Modules/webdatabase/DatabaseBackend.h (modified) (2 diffs)
• Modules/webdatabase/DatabaseBackendAsync.cpp (modified) (3 diffs)
• Modules/webdatabase/DatabaseBackendAsync.h (modified) (3 diffs)
• Modules/webdatabase/DatabaseBackendContext.cpp (modified) (1 diff)
• Modules/webdatabase/DatabaseBackendContext.h (modified) (1 diff)
• Modules/webdatabase/DatabaseManager.cpp (modified) (1 diff)
• Modules/webdatabase/DatabaseManager.h (modified) (1 diff)
• Modules/webdatabase/DatabaseServer.cpp (modified) (1 diff)
• Modules/webdatabase/DatabaseServer.h (modified) (1 diff)
• Modules/webdatabase/DatabaseTask.cpp (modified) (1 diff)
• Modules/webdatabase/SQLTransaction.cpp (modified) (1 diff)
• Modules/webdatabase/SQLTransaction.h (modified) (1 diff)
• Modules/webdatabase/SQLTransactionBackend.cpp (modified) (22 diffs)
• Modules/webdatabase/SQLTransactionBackend.h (modified) (3 diffs)
• Modules/webdatabase/SQLTransactionClient.cpp (modified) (3 diffs)
• Modules/webdatabase/SQLTransactionCoordinator.cpp (modified) (2 diffs)
• Modules/webdatabase/SQLTransactionState.h (added)
• Modules/webdatabase/SQLTransactionStateMachine.cpp (added)
• Modules/webdatabase/SQLTransactionStateMachine.h (added)
• Target.pri (modified) (3 diffs)
• WebCore.gypi (modified) (2 diffs)
• WebCore.vcproj/WebCore.vcproj (modified) (2 diffs)
• WebCore.vcxproj/WebCore.vcxproj (modified) (3 diffs)
• WebCore.vcxproj/WebCore.vcxproj.filters (modified) (4 diffs)
• WebCore.xcodeproj/project.pbxproj (modified) (11 diffs)
• inspector/InspectorDatabaseAgent.cpp (modified) (1 diff)

trunk/Source/WebCore/CMakeLists.txt

@@ -964 +964 @@
     Modules/webdatabase/SQLTransactionClient.cpp
     Modules/webdatabase/SQLTransactionCoordinator.cpp
+    Modules/webdatabase/SQLTransactionStateMachine.cpp
     Modules/webdatabase/SQLTransactionSync.cpp
 

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2013-02-14  Mark Lam  <mark.lam@apple.com>
+
+        Split SQLTransaction work between the frontend and backend.
+        https://bugs.webkit.org/show_bug.cgi?id=104750.
+
+        Reviewed by Sam Weinig.
+
+        This is part of the webdatabase refactoring for webkit2.
+
+        1. Changed how transactions are created.
+
+           - Database::runTransaction() first creates a SQLTransaction frontend
+             which encapsulates the 3 script callbacks. It then passes the
+             SQLTransaction to the backend database to create the
+             SQLTransactionBackend.
+           - The SQLTransactionBackend manages all SQLiteTransaction work.
+
+        2. Introduced SQLTransactionState and SQLTransactionStateMachine.
+
+           - Instead of tracking the transaction phases as "steps" in m_nextStep,
+             we now use m_nextState which is of enum class SQLTransactionState.
+             Unlike m_nextStep which is a pointer to a "step" function,
+             m_nextState is a state variable which is used to index into a
+             state dispatch table.
+
+           - Both SQLTransaction and SQLTransactionBackend now extends
+             SQLTransactionStateMachine, and uses its dispatch mechanism based on
+             the SQLTransactionState.
+
+           - Instead of having 1 state machine instances, there are 2: 1 in the
+             frontend, and 1 in the backend. The 2 have mirrored states, and
+             transfers work to the other state machine when needed.
+
+           - Previously, state functions can be called inline from other states.
+             They are now only called from the state machines runStateMachine()
+             method. This makes it possible to isolate the state transition
+             mechanism going between the sides (frontend and backend) to 2
+             functions only: SQLTransaction::sendToBackendState() and
+             SQLTransactionBackend::sendToFrontendState().
+
+        3. Consolidated cleanup work (mostly) to a unified cleanup function.
+
+        4. Changed the frontend Database::runTransaction() to use a
+           ChangeVersionData* (instead of a ChangeVersionWrapper ref ptr).
+
+           - This is necessary because ChangeVersionWrapper contains functionality
+             used in processing a transaction (to be invoked in the backend).
+             Instead, what we want is to simply pass the 2 old and new version
+             strings to the backend. The new ChangeVersionData simply packages up
+             these 2 strings.
+           - This makes ChangeVersionData easy to serialize for IPC messaging later.
+
+        5. Moved some transaction functions back to the frontend SQLTransaction
+           because they belong there.
+
+        6. Moved some Database functions to its DatabaseBackendAsync backend
+           now that the transaction has been split up.
+
+           - This is driven naturally by those functions being used exclusively
+             in the backend for transaction work.
+           - SQLTransactionClient, SQLTransactionCoordinator, and
+             SQLTransactionWrapper are now exclusively backend data structures.
+             SQLTransactionClient still has some frontend "pollution" that I'll
+             fix later.
+
+        7. Made the few database report functions used only by Chromium conditional
+           on PLATFORM(chromium).
+
+           - The report functions gets re-routed to Chromium's DatabaseObserver
+             which further routes them elsewhere. It is unclear how Chromium uses
+             these routed messages, and I am therefore not able to determine how
+             they should work in a frontend/backend world. So, I'm #ifdef'ing
+             them out. They still work like in the old way for Chromium.
+
+        8. Added new files to the build / project files.
+
+        9. Updated / added comments about how the transaction and its states work.
+
+        No new tests.
+
+        * CMakeLists.txt:
+        * GNUmakefile.list.am:
+        * Modules/webdatabase/AbstractDatabaseServer.h:
+        * Modules/webdatabase/ChangeVersionData.h: Added.
+        (ChangeVersionData):
+        (WebCore::ChangeVersionData::ChangeVersionData):
+        (WebCore::ChangeVersionData::oldVersion):
+        (WebCore::ChangeVersionData::newVersion):
+        * Modules/webdatabase/ChangeVersionWrapper.cpp:
+        (WebCore::ChangeVersionWrapper::performPreflight):
+        (WebCore::ChangeVersionWrapper::performPostflight):
+        (WebCore::ChangeVersionWrapper::handleCommitFailedAfterPostflight):
+        * Modules/webdatabase/ChangeVersionWrapper.h:
+        (ChangeVersionWrapper):
+        * Modules/webdatabase/Database.cpp:
+        (WebCore::Database::Database):
+        (WebCore::Database::close):
+        (WebCore::Database::changeVersion):
+        (WebCore::Database::transaction):
+        (WebCore::Database::readTransaction):
+        (WebCore::Database::runTransaction):
+        (WebCore::Database::reportStartTransactionResult):
+        (WebCore::Database::reportCommitTransactionResult):
+        (WebCore::Database::reportExecuteStatementResult):
+        * Modules/webdatabase/Database.h:
+        (WebCore::Database::databaseContext):
+        (Database):
+        (WebCore::Database::reportStartTransactionResult):
+        (WebCore::Database::reportCommitTransactionResult):
+        (WebCore::Database::reportExecuteStatementResult):
+        * Modules/webdatabase/DatabaseBackend.cpp:
+        * Modules/webdatabase/DatabaseBackend.h:
+        (DatabaseBackend):
+        (WebCore::DatabaseBackend::reportOpenDatabaseResult):
+        (WebCore::DatabaseBackend::reportChangeVersionResult):
+        (WebCore::DatabaseBackend::reportStartTransactionResult):
+        (WebCore::DatabaseBackend::reportCommitTransactionResult):
+        (WebCore::DatabaseBackend::reportExecuteStatementResult):
+        (WebCore::DatabaseBackend::reportVacuumDatabaseResult):
+        * Modules/webdatabase/DatabaseBackendAsync.cpp:
+        (WebCore::DatabaseBackendAsync::DatabaseBackendAsync):
+        (WebCore::DatabaseBackendAsync::runTransaction):
+        (WebCore::DatabaseBackendAsync::inProgressTransactionCompleted): Moved from frontend.
+        (WebCore::DatabaseBackendAsync::scheduleTransaction): Moved from frontend.
+        (WebCore::DatabaseBackendAsync::scheduleTransactionStep): Moved from frontend.
+        (WebCore::DatabaseBackendAsync::transactionClient): Moved from frontend.
+        (WebCore::DatabaseBackendAsync::transactionCoordinator): Moved from frontend.
+        * Modules/webdatabase/DatabaseBackendAsync.h:
+        (DatabaseBackendAsync):
+        * Modules/webdatabase/DatabaseBackendContext.cpp:
+        (WebCore::DatabaseBackendContext::frontend):
+        * Modules/webdatabase/DatabaseBackendContext.h:
+        (DatabaseBackendContext):
+        * Modules/webdatabase/DatabaseManager.cpp:
+        * Modules/webdatabase/DatabaseManager.h:
+        (DatabaseManager):
+        * Modules/webdatabase/DatabaseServer.cpp:
+        * Modules/webdatabase/DatabaseServer.h:
+        * Modules/webdatabase/DatabaseTask.cpp:
+        (WebCore::DatabaseBackendAsync::DatabaseTransactionTask::doPerformTask):
+        * Modules/webdatabase/SQLTransaction.cpp:
+        (WebCore::SQLTransaction::create):
+        (WebCore::SQLTransaction::SQLTransaction):
+        (WebCore::SQLTransaction::setBackend):
+        (WebCore::SQLTransaction::stateFunctionFor):
+        (WebCore::SQLTransaction::requestTransitToState):
+        (WebCore::SQLTransaction::nextStateForTransactionError):
+            - was handleTransactionError(). There's also a backend version.
+        (WebCore::SQLTransaction::deliverTransactionCallback): Moved from backend.
+        (WebCore::SQLTransaction::deliverTransactionErrorCallback): Moved from backend.
+        (WebCore::SQLTransaction::deliverStatementCallback): Moved from backend.
+        (WebCore::SQLTransaction::deliverQuotaIncreaseCallback): Moved from backend.
+        (WebCore::SQLTransaction::deliverSuccessCallback): Moved from backend.
+        (WebCore::SQLTransaction::unreachableState):
+        (WebCore::SQLTransaction::sendToBackendState):
+        (WebCore::SQLTransaction::performPendingCallback): Moved from backend.
+        (WebCore::SQLTransaction::executeSQL): Moved from backend.
+        (WebCore::SQLTransaction::checkAndHandleClosedOrInterruptedDatabase):
+        (WebCore::SQLTransaction::clearCallbackWrappers):
+        * Modules/webdatabase/SQLTransaction.h:
+        (SQLTransaction):
+        (WebCore::SQLTransaction::database):
+        (WebCore::SQLTransaction::hasCallback):
+        (WebCore::SQLTransaction::hasSuccessCallback):
+        (WebCore::SQLTransaction::hasErrorCallback):
+        * Modules/webdatabase/SQLTransactionBackend.cpp:
+        (WebCore::SQLTransactionBackend::create):
+        (WebCore::SQLTransactionBackend::SQLTransactionBackend):
+        (WebCore::SQLTransactionBackend::doCleanup):
+        (WebCore::SQLTransactionBackend::transactionError):
+        (WebCore::SQLTransactionBackend::setShouldRetryCurrentStatement):
+        (WebCore::SQLTransactionBackend::stateFunctionFor):
+        (WebCore::SQLTransactionBackend::enqueueStatement):
+        (WebCore::SQLTransactionBackend::checkAndHandleClosedOrInterruptedDatabase):
+        (WebCore::SQLTransactionBackend::performNextStep):
+        (WebCore::SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown):
+        (WebCore::SQLTransactionBackend::acquireLock):
+        (WebCore::SQLTransactionBackend::lockAcquired):
+        (WebCore::SQLTransactionBackend::openTransactionAndPreflight):
+        (WebCore::SQLTransactionBackend::runStatements):
+        (WebCore::SQLTransactionBackend::runCurrentStatementAndGetNextState):
+            - was runCurrentStatement().
+        (WebCore::SQLTransactionBackend::nextStateForCurrentStatementError):
+            - was handleCurrentStatementError().
+        (WebCore::SQLTransactionBackend::postflightAndCommit):
+        (WebCore::SQLTransactionBackend::cleanupAndTerminate):
+        (WebCore::SQLTransactionBackend::nextStateForTransactionError):
+            - was handleTransactionError(). There's also a frontend version.
+        (WebCore::SQLTransactionBackend::cleanupAfterTransactionErrorCallback):
+        (WebCore::SQLTransactionBackend::requestTransitToState):
+        (WebCore::SQLTransactionBackend::unreachableState):
+        (WebCore::SQLTransactionBackend::sendToFrontendState):
+        * Modules/webdatabase/SQLTransactionBackend.h:
+        (SQLTransactionWrapper):
+        (SQLTransactionBackend):
+        (WebCore::SQLTransactionBackend::database):
+        * Modules/webdatabase/SQLTransactionClient.cpp:
+        (WebCore::SQLTransactionClient::didCommitWriteTransaction):
+        (WebCore::SQLTransactionClient::didExecuteStatement):
+        * Modules/webdatabase/SQLTransactionCoordinator.cpp:
+        (WebCore::getDatabaseIdentifier):
+        * Modules/webdatabase/SQLTransactionState.h: Added.
+        * Modules/webdatabase/SQLTransactionStateMachine.cpp: Added.
+        (WebCore::nameForSQLTransactionState):
+            - was debugStepName().
+        * Modules/webdatabase/SQLTransactionStateMachine.h: Added.
+        (SQLTransactionStateMachine):
+        (WebCore::SQLTransactionStateMachine::~SQLTransactionStateMachine):
+        (WebCore::::SQLTransactionStateMachine):
+        (WebCore::::setStateToRequestedState):
+        (WebCore::::runStateMachine):
+        * Target.pri:
+        * WebCore.gypi:
+        * WebCore.vcproj/WebCore.vcproj:
+        * WebCore.vcxproj/WebCore.vcxproj:
+        * WebCore.vcxproj/WebCore.vcxproj.filters:
+        * WebCore.xcodeproj/project.pbxproj:
+        * inspector/InspectorDatabaseAgent.cpp:
+
 2013-02-14  Jer Noble  <jer.noble@apple.com>
 

trunk/Source/WebCore/GNUmakefile.list.am

@@ -2101 +2101 @@
         Source/WebCore/Modules/webaudio/WaveTable.h \
         Source/WebCore/Modules/webdatabase/AbstractDatabaseServer.h \
+        Source/WebCore/Modules/webdatabase/ChangeVersionData.h \
         Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.cpp \
         Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.h \
@@ -2169 +2170 @@
         Source/WebCore/Modules/webdatabase/SQLTransactionErrorCallback.h \
         Source/WebCore/Modules/webdatabase/SQLTransactionSyncCallback.h \
+        Source/WebCore/Modules/webdatabase/SQLTransactionState.h \
+        Source/WebCore/Modules/webdatabase/SQLTransactionStateMachine.cpp \
+        Source/WebCore/Modules/webdatabase/SQLTransactionStateMachine.h \
         Source/WebCore/Modules/webdatabase/SQLTransactionSync.cpp \
         Source/WebCore/Modules/webdatabase/SQLTransactionSync.h \

trunk/Source/WebCore/Modules/webdatabase/AbstractDatabaseServer.h

@@ -75 +75 @@
     virtual bool deleteDatabase(SecurityOrigin*, const String& name) = 0;
 
-    // From a secondary thread, must be thread safe with its data
-    virtual void scheduleNotifyDatabaseChanged(SecurityOrigin*, const String& name) = 0;
-    virtual void databaseChanged(DatabaseBackend*) = 0;
-
 #else // PLATFORM(CHROMIUM)
     virtual void closeDatabasesImmediately(const String& originIdentifier, const String& name) = 0;

trunk/Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.cpp

@@ -1 +1 @@
 /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -44 +44 @@
 }
 
-bool ChangeVersionWrapper::performPreflight(SQLTransaction* transaction)
+bool ChangeVersionWrapper::performPreflight(SQLTransactionBackend* transaction)
 {
     ASSERT(transaction && transaction->database());
 
-    Database* database = transaction->database();
+    DatabaseBackendAsync* database = transaction->database();
 
     String actualVersion;
@@ -68 +68 @@
 }
 
-bool ChangeVersionWrapper::performPostflight(SQLTransaction* transaction)
+bool ChangeVersionWrapper::performPostflight(SQLTransactionBackend* transaction)
 {
     ASSERT(transaction && transaction->database());
 
-    Database* database = transaction->database();
+    DatabaseBackendAsync* database = transaction->database();
 
     if (!database->setVersionInDatabase(m_newVersion)) {
@@ -88 +88 @@
 }
 
-void ChangeVersionWrapper::handleCommitFailedAfterPostflight(SQLTransaction* transaction)
+void ChangeVersionWrapper::handleCommitFailedAfterPostflight(SQLTransactionBackend* transaction)
 {
     transaction->database()->setCachedVersion(m_oldVersion);

trunk/Source/WebCore/Modules/webdatabase/ChangeVersionWrapper.h

@@ -1 +1 @@
 /*
- * Copyright (C) 2007 Apple Inc. All rights reserved.
+ * Copyright (C) 2007, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31 +31 @@
 #if ENABLE(SQL_DATABASE)
 
-#include "SQLTransaction.h"
+#include "SQLTransactionBackend.h"
 #include <wtf/Forward.h>
 
@@ -42 +42 @@
     static PassRefPtr<ChangeVersionWrapper> create(const String& oldVersion, const String& newVersion) { return adoptRef(new ChangeVersionWrapper(oldVersion, newVersion)); }
 
-    virtual bool performPreflight(SQLTransaction*);
-    virtual bool performPostflight(SQLTransaction*);
+    virtual bool performPreflight(SQLTransactionBackend*);
+    virtual bool performPostflight(SQLTransactionBackend*);
     virtual SQLError* sqlError() const { return m_sqlError.get(); }
-    virtual void handleCommitFailedAfterPostflight(SQLTransaction*);
+    virtual void handleCommitFailedAfterPostflight(SQLTransactionBackend*);
 
 private:

trunk/Source/WebCore/Modules/webdatabase/Database.cpp

@@ -32 +32 @@
 #if ENABLE(SQL_DATABASE)
 
-#include "ChangeVersionWrapper.h"
+#include "ChangeVersionData.h"
 #include "CrossThreadTask.h"
 #include "DatabaseBackendContext.h"
@@ -46 +46 @@
 #include "Page.h"
 #include "SQLError.h"
+#include "SQLTransaction.h"
 #include "SQLTransactionCallback.h"
-#include "SQLTransactionClient.h"
-#include "SQLTransactionCoordinator.h"
 #include "SQLTransactionErrorCallback.h"
 #include "SQLiteStatement.h"
@@ -69 +68 @@
 PassRefPtr<Database> Database::create(ScriptExecutionContext*, PassRefPtr<DatabaseBackend> backend)
 {
+    // FIXME: Currently, we're only simulating the backend by return the
+    // frontend database as its own the backend. When we split the 2 apart,
+    // this create() function should be changed to be a factory method for
+    // instantiating the backend.
     return static_cast<Database*>(backend.get());
 }
@@ -76 +79 @@
     : DatabaseBase(databaseContext->scriptExecutionContext())
     , DatabaseBackendAsync(databaseContext, name, expectedVersion, displayName, estimatedSize)
-    , m_transactionInProgress(false)
-    , m_isTransactionQueueEnabled(true)
+    , m_databaseContext(DatabaseBackendAsync::databaseContext()->frontend())
     , m_deleted(false)
 {
@@ -163 +165 @@
     ASSERT(currentThread() == databaseContext()->databaseThread()->getThreadID());
 
-    {
-        MutexLocker locker(m_transactionInProgressMutex);
-        m_isTransactionQueueEnabled = false;
-        m_transactionInProgress = false;
-        m_transactionQueue.clear();
-    }
-
     closeDatabase();
 
@@ -197 +192 @@
                              PassRefPtr<VoidCallback> successCallback)
 {
-    runTransaction(callback, errorCallback, successCallback, ChangeVersionWrapper::create(oldVersion, newVersion), false);
+    ChangeVersionData data(oldVersion, newVersion);
+    runTransaction(callback, errorCallback, successCallback, false, &data);
 }
 
 void Database::transaction(PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback)
 {
-    runTransaction(callback, errorCallback, successCallback, 0, false);
+    runTransaction(callback, errorCallback, successCallback, false);
 }
 
 void Database::readTransaction(PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback)
 {
-    runTransaction(callback, errorCallback, successCallback, 0, true);
+    runTransaction(callback, errorCallback, successCallback, true);
 }
 
@@ -216 +212 @@
 
 void Database::runTransaction(PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
-                              PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
-{
-    MutexLocker locker(m_transactionInProgressMutex);
-    if (!m_isTransactionQueueEnabled) {
-        if (errorCallback) {
-            RefPtr<SQLError> error = SQLError::create(SQLError::UNKNOWN_ERR, "database has been closed");
-            scriptExecutionContext()->postTask(createCallbackTask(&callTransactionErrorCallback, errorCallback, error.release()));
-        }
-        return;
-    }
-    RefPtr<SQLTransaction> transaction = SQLTransaction::create(this, callback, errorCallback, successCallback, wrapper, readOnly);
-    m_transactionQueue.append(transaction.release());
-    if (!m_transactionInProgress)
-        scheduleTransaction();
-}
-
-void Database::inProgressTransactionCompleted()
-{
-    MutexLocker locker(m_transactionInProgressMutex);
-    m_transactionInProgress = false;
-    scheduleTransaction();
-}
-
-void Database::scheduleTransaction()
-{
-    ASSERT(!m_transactionInProgressMutex.tryLock()); // Locked by caller.
-    RefPtr<SQLTransaction> transaction;
-
-    if (m_isTransactionQueueEnabled && !m_transactionQueue.isEmpty())
-        transaction = m_transactionQueue.takeFirst();
-
-    if (transaction && databaseContext()->databaseThread()) {
-        OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
-        LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
-        m_transactionInProgress = true;
-        databaseContext()->databaseThread()->scheduleTask(task.release());
-    } else
-        m_transactionInProgress = false;
-}
-
-void Database::scheduleTransactionStep(SQLTransactionBackend* transaction, bool immediately)
-{
-    if (!databaseContext()->databaseThread())
-        return;
-
-    OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
-    LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
-    if (immediately)
-        databaseContext()->databaseThread()->scheduleImmediateTask(task.release());
-    else
-        databaseContext()->databaseThread()->scheduleTask(task.release());
+    PassRefPtr<VoidCallback> successCallback, bool readOnly, const ChangeVersionData* changeVersionData)
+{
+    RefPtr<SQLTransactionErrorCallback> anotherRefToErrorCallback = errorCallback;
+    RefPtr<SQLTransaction> transaction = SQLTransaction::create(this, callback, successCallback, anotherRefToErrorCallback, readOnly);
+
+    RefPtr<SQLTransactionBackend> transactionBackend;
+    transactionBackend = backend()->runTransaction(transaction.release(), readOnly, changeVersionData);
+    if (!transactionBackend && anotherRefToErrorCallback) {
+        RefPtr<SQLError> error = SQLError::create(SQLError::UNKNOWN_ERR, "database has been closed");
+        scriptExecutionContext()->postTask(createCallbackTask(&callTransactionErrorCallback, anotherRefToErrorCallback, error.release()));
+    }
 }
 
@@ -324 +280 @@
 }
 
-SQLTransactionClient* Database::transactionClient() const
-{
-    return databaseContext()->databaseThread()->transactionClient();
-}
-
-SQLTransactionCoordinator* Database::transactionCoordinator() const
-{
-    return databaseContext()->databaseThread()->transactionCoordinator();
-}
-
 Vector<String> Database::tableNames()
 {
@@ -359 +305 @@
 }
 
+#if PLATFORM(CHROMIUM)
+void Database::reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+{
+    backend()->reportStartTransactionResult(errorSite, webSqlErrorCode, sqliteErrorCode);
+}
+
+void Database::reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+{
+    backend()->reportCommitTransactionResult(errorSite, webSqlErrorCode, sqliteErrorCode);
+}
+
+void Database::reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode)
+{
+    backend()->reportExecuteStatementResult(errorSite, webSqlErrorCode, sqliteErrorCode);
+}
+#endif
+
 } // namespace WebCore
 

trunk/Source/WebCore/Modules/webdatabase/Database.h

@@ -36 +36 @@
 #include "DatabaseBasicTypes.h"
 #include "DatabaseError.h"
-#include <wtf/Deque.h>
-#include <wtf/Forward.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
+class ChangeVersionData;
 class DatabaseCallback;
+class DatabaseContext;
 class SecurityOrigin;
 class SQLTransaction;
 class SQLTransactionBackend;
 class SQLTransactionCallback;
-class SQLTransactionClient;
-class SQLTransactionCoordinator;
 class SQLTransactionErrorCallback;
-class SQLTransactionWrapper;
 class VoidCallback;
 
@@ -66 +63 @@
     // Internal engine support
     static Database* from(DatabaseBackendAsync*);
+    DatabaseContext* databaseContext() const { return m_databaseContext.get(); }
 
     Vector<String> tableNames();
@@ -81 +79 @@
 
     void scheduleTransactionCallback(SQLTransaction*);
-    void scheduleTransactionStep(SQLTransactionBackend*, bool immediately = false);
-
-    SQLTransactionClient* transactionClient() const;
-    SQLTransactionCoordinator* transactionCoordinator() const;
 
 private:
@@ -93 +87 @@
 
     void runTransaction(PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
-                        PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
-
-    void inProgressTransactionCompleted();
-    void scheduleTransaction();
+        PassRefPtr<VoidCallback> successCallback, bool readOnly, const ChangeVersionData* = 0);
 
     Vector<String> performGetTableNames();
 
-    Deque<RefPtr<SQLTransaction> > m_transactionQueue;
-    Mutex m_transactionInProgressMutex;
-    bool m_transactionInProgress;
-    bool m_isTransactionQueueEnabled;
+#if PLATFORM(CHROMIUM)
+    void reportStartTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
+    void reportCommitTransactionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
+    void reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
+#else
+    void reportStartTransactionResult(int, int, int) { }
+    void reportCommitTransactionResult(int, int, int) { }
+    void reportExecuteStatementResult(int, int, int) { }
+#endif
 
     RefPtr<SecurityOrigin> m_databaseThreadSecurityOrigin;
+    RefPtr<DatabaseContext> m_databaseContext;
 
     bool m_deleted;
@@ -112 +109 @@
     friend class DatabaseServer; // FIXME: remove this when the backend has been split out.
     friend class DatabaseBackendAsync; // FIXME: remove this when the backend has been split out.
+    friend class SQLStatement;
+    friend class SQLTransaction;
 };
 

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.cpp

@@ -653 +653 @@
 }
 
-#else
-void DatabaseBackend::reportOpenDatabaseResult(int, int, int) { }
-void DatabaseBackend::reportChangeVersionResult(int, int, int) { }
-void DatabaseBackend::reportStartTransactionResult(int, int, int) { }
-void DatabaseBackend::reportCommitTransactionResult(int, int, int) { }
-void DatabaseBackend::reportExecuteStatementResult(int, int, int) { }
-void DatabaseBackend::reportVacuumDatabaseResult(int) { }
 #endif // PLATFORM(CHROMIUM)
 

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackend.h

@@ -115 +115 @@
     bool getActualVersionForTransaction(String& version);
 
+#if PLATFORM(CHROMIUM)
     void reportOpenDatabaseResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
     void reportChangeVersionResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
@@ -121 +122 @@
     void reportExecuteStatementResult(int errorSite, int webSqlErrorCode, int sqliteErrorCode);
     void reportVacuumDatabaseResult(int sqliteErrorCode);
+#else
+    void reportOpenDatabaseResult(int, int, int) { }
+    void reportChangeVersionResult(int, int, int) { }
+    void reportStartTransactionResult(int, int, int) { }
+    void reportCommitTransactionResult(int, int, int) { }
+    void reportExecuteStatementResult(int, int, int) { }
+    void reportVacuumDatabaseResult(int) { }
+#endif
 
     static const char* databaseInfoTableName();

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.cpp

@@ -29 +29 @@
 #if ENABLE(SQL_DATABASE)
 
+#include "ChangeVersionData.h"
+#include "ChangeVersionWrapper.h"
 #include "DatabaseBackendContext.h"
 #include "DatabaseTask.h"
 #include "DatabaseThread.h"
 #include "DatabaseTracker.h"
+#include "Logging.h"
+#include "SQLTransaction.h"
+#include "SQLTransactionBackend.h"
+#include "SQLTransactionClient.h"
+#include "SQLTransactionCoordinator.h"
 
 namespace WebCore {
@@ -38 +45 @@
 DatabaseBackendAsync::DatabaseBackendAsync(PassRefPtr<DatabaseBackendContext> databaseContext, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize)
     : DatabaseBackend(databaseContext, name, expectedVersion, displayName, estimatedSize, DatabaseType::Async)
+    , m_transactionInProgress(false)
+    , m_isTransactionQueueEnabled(true)
 {
 }
@@ -70 +79 @@
 }
 
+PassRefPtr<SQLTransactionBackend> DatabaseBackendAsync::runTransaction(PassRefPtr<SQLTransaction> transaction,
+    bool readOnly, const ChangeVersionData* data)
+{
+    MutexLocker locker(m_transactionInProgressMutex);
+    if (!m_isTransactionQueueEnabled)
+        return 0;
+
+    RefPtr<SQLTransactionWrapper> wrapper;
+    if (data)
+        wrapper = ChangeVersionWrapper::create(data->oldVersion(), data->newVersion());
+
+    RefPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, transaction, wrapper, readOnly);
+    m_transactionQueue.append(transactionBackend);
+    if (!m_transactionInProgress)
+        scheduleTransaction();
+
+    return transactionBackend;
+}
+
+void DatabaseBackendAsync::inProgressTransactionCompleted()
+{
+    MutexLocker locker(m_transactionInProgressMutex);
+    m_transactionInProgress = false;
+    scheduleTransaction();
+}
+
+void DatabaseBackendAsync::scheduleTransaction()
+{
+    ASSERT(!m_transactionInProgressMutex.tryLock()); // Locked by caller.
+    RefPtr<SQLTransactionBackend> transaction;
+
+    if (m_isTransactionQueueEnabled && !m_transactionQueue.isEmpty())
+        transaction = m_transactionQueue.takeFirst();
+
+    if (transaction && databaseContext()->databaseThread()) {
+        OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
+        LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for transaction %p\n", task.get(), task->transaction());
+        m_transactionInProgress = true;
+        databaseContext()->databaseThread()->scheduleTask(task.release());
+    } else
+        m_transactionInProgress = false;
+}
+
+void DatabaseBackendAsync::scheduleTransactionStep(SQLTransactionBackend* transaction)
+{
+    if (!databaseContext()->databaseThread())
+        return;
+
+    OwnPtr<DatabaseTransactionTask> task = DatabaseTransactionTask::create(transaction);
+    LOG(StorageAPI, "Scheduling DatabaseTransactionTask %p for the transaction step\n", task.get());
+    databaseContext()->databaseThread()->scheduleTask(task.release());
+}
+
+SQLTransactionClient* DatabaseBackendAsync::transactionClient() const
+{
+    return databaseContext()->databaseThread()->transactionClient();
+}
+
+SQLTransactionCoordinator* DatabaseBackendAsync::transactionCoordinator() const
+{
+    return databaseContext()->databaseThread()->transactionCoordinator();
+}
+
 } // namespace WebCore
 

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendAsync.h

@@ -30 +30 @@
 
 #include "DatabaseBackend.h"
+#include <wtf/Deque.h>
 #include <wtf/text/WTFString.h>
 
 namespace WebCore {
 
+class ChangeVersionData;
 class Database;
 class DatabaseServer;
+class SQLTransaction;
+class SQLTransactionBackend;
+class SQLTransactionClient;
+class SQLTransactionCoordinator;
 
 // FIXME: This implementation of DatabaseBackendAsync is only a place holder
@@ -48 +54 @@
 
     virtual bool openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError&, String& errorMessage);
-    virtual bool performOpenAndVerify(bool setVersionInNewDatabase, DatabaseError&, String& errorMessage);
+
+    PassRefPtr<SQLTransactionBackend> runTransaction(PassRefPtr<SQLTransaction>, bool readOnly, const ChangeVersionData*);
+    void scheduleTransactionStep(SQLTransactionBackend*);
+    void inProgressTransactionCompleted();
+
+    SQLTransactionClient* transactionClient() const;
+    SQLTransactionCoordinator* transactionCoordinator() const;
 
 private:
@@ -55 +67 @@
     class DatabaseTransactionTask;
     class DatabaseTableNamesTask;
+
+    virtual bool performOpenAndVerify(bool setVersionInNewDatabase, DatabaseError&, String& errorMessage);
+
+    void scheduleTransaction();
+
+    Deque<RefPtr<SQLTransactionBackend> > m_transactionQueue;
+    Mutex m_transactionInProgressMutex;
+    bool m_transactionInProgress;
+    bool m_isTransactionQueueEnabled;
 
     friend class Database;

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendContext.cpp

@@ -33 +33 @@
 namespace WebCore {
 
+DatabaseContext* DatabaseBackendContext::frontend()
+{
+    // FIXME: Currently, we're only simulating the frontend by return the
+    // backend context as its own the frontend. When we split the 2 apart, this
+    // create() function should be changed to return a cached m_frontend.
+    return static_cast<DatabaseContext*>(this);
+}
+
 SecurityOrigin* DatabaseBackendContext::securityOrigin() const
 {

trunk/Source/WebCore/Modules/webdatabase/DatabaseBackendContext.h

@@ -44 +44 @@
 class DatabaseBackendContext : public DatabaseContext {
 public:
+    DatabaseContext* frontend();
+
     ScriptExecutionContext* scriptExecutionContext() const { return m_scriptExecutionContext; }
     SecurityOrigin* securityOrigin() const;

trunk/Source/WebCore/Modules/webdatabase/DatabaseManager.cpp

@@ -415 +415 @@
 }
 
-// From a secondary thread, must be thread safe with its data
-void DatabaseManager::scheduleNotifyDatabaseChanged(SecurityOrigin* origin, const String& name)
-{
-    m_server->scheduleNotifyDatabaseChanged(origin, name);
-}
-
-void DatabaseManager::databaseChanged(DatabaseBackend* database)
-{
-    m_server->databaseChanged(database);
-}
-
 #else // PLATFORM(CHROMIUM)
 void DatabaseManager::closeDatabasesImmediately(const String& originIdentifier, const String& name)

trunk/Source/WebCore/Modules/webdatabase/DatabaseManager.h

@@ -105 +105 @@
     bool deleteDatabase(SecurityOrigin*, const String& name);
 
-    // From a secondary thread, must be thread safe with its data
-    void scheduleNotifyDatabaseChanged(SecurityOrigin*, const String& name);
-
-    void databaseChanged(DatabaseBackend*);
-
 #else // PLATFORM(CHROMIUM)
     void closeDatabasesImmediately(const String& originIdentifier, const String& name);

trunk/Source/WebCore/Modules/webdatabase/DatabaseServer.cpp

@@ -129 +129 @@
 }
 
-// From a secondary thread, must be thread safe with its data
-void DatabaseServer::scheduleNotifyDatabaseChanged(SecurityOrigin* origin, const String& name)
-{
-    DatabaseTracker::tracker().scheduleNotifyDatabaseChanged(origin, name);
-}
-
-void DatabaseServer::databaseChanged(DatabaseBackend* database)
-{
-    DatabaseTracker::tracker().databaseChanged(database);
-}
-
 #else // PLATFORM(CHROMIUM)
 void DatabaseServer::closeDatabasesImmediately(const String& originIdentifier, const String& name)

trunk/Source/WebCore/Modules/webdatabase/DatabaseServer.h

@@ -63 +63 @@
     virtual bool deleteDatabase(SecurityOrigin*, const String& name);
 
-    // From a secondary thread, must be thread safe with its data
-    virtual void scheduleNotifyDatabaseChanged(SecurityOrigin*, const String& name);
-    virtual void databaseChanged(DatabaseBackend*);
-
 #else // PLATFORM(CHROMIUM)
     virtual void closeDatabasesImmediately(const String& originIdentifier, const String& name);

trunk/Source/WebCore/Modules/webdatabase/DatabaseTask.cpp

@@ -156 +156 @@
 void DatabaseBackendAsync::DatabaseTransactionTask::doPerformTask()
 {
-    if (m_transaction->performNextStep())
-        Database::from(m_transaction->database())->inProgressTransactionCompleted();
+    m_transaction->performNextStep();
 }
 

trunk/Source/WebCore/Modules/webdatabase/SQLTransaction.cpp

@@ -32 +32 @@
 #if ENABLE(SQL_DATABASE)
 
+#include "Database.h"
+#include "DatabaseAuthorizer.h"
+#include "DatabaseContext.h"
+#include "ExceptionCode.h"
+#include "Logging.h"
+#include "SQLError.h"
+#include "SQLStatementCallback.h"
+#include "SQLStatementErrorCallback.h"
+#include "SQLTransactionBackend.h"
 #include "SQLTransactionCallback.h"
+#include "SQLTransactionClient.h"
 #include "SQLTransactionErrorCallback.h"
 #include "VoidCallback.h"
+#include <wtf/StdLibExtras.h>
+#include <wtf/Vector.h>
 
 namespace WebCore {
 
 PassRefPtr<SQLTransaction> SQLTransaction::create(Database* db, PassRefPtr<SQLTransactionCallback> callback,
-    PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
-    PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
-{
-    return adoptRef(new SQLTransaction(db, callback, errorCallback, successCallback, wrapper, readOnly));
+    PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
+    bool readOnly)
+{
+    return adoptRef(new SQLTransaction(db, callback, successCallback, errorCallback, readOnly));
 }
 
 SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback,
-    PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
-    PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
-    : SQLTransactionBackend(db, callback, errorCallback, successCallback, wrapper, readOnly)
-{
-}
-
-SQLTransaction* SQLTransaction::from(SQLTransactionBackend* backend)
-{
-    return static_cast<SQLTransaction*>(backend);
+    PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionErrorCallback> errorCallback,
+    bool readOnly)
+    : m_database(db)
+    , m_callbackWrapper(callback, db->scriptExecutionContext())
+    , m_successCallbackWrapper(successCallback, db->scriptExecutionContext())
+    , m_errorCallbackWrapper(errorCallback, db->scriptExecutionContext())
+    , m_executeSqlAllowed(false)
+    , m_readOnly(readOnly)
+{
+    ASSERT(m_database);
+}
+
+void SQLTransaction::setBackend(SQLTransactionBackend* backend)
+{
+    ASSERT(!m_backend);
+    m_backend = backend;
+}
+
+SQLTransaction::StateFunction SQLTransaction::stateFunctionFor(SQLTransactionState state)
+{
+    static const StateFunction stateFunctions[] = {
+        &SQLTransaction::unreachableState,                // 0. illegal
+        &SQLTransaction::unreachableState,                // 1. idle
+        &SQLTransaction::unreachableState,                // 2. acquireLock
+        &SQLTransaction::unreachableState,                // 3. openTransactionAndPreflight
+        &SQLTransaction::sendToBackendState,              // 4. runStatements
+        &SQLTransaction::unreachableState,                // 5. postflightAndCommit
+        &SQLTransaction::sendToBackendState,              // 6. cleanupAndTerminate
+        &SQLTransaction::sendToBackendState,              // 7. cleanupAfterTransactionErrorCallback
+        &SQLTransaction::deliverTransactionCallback,      // 8.
+        &SQLTransaction::deliverTransactionErrorCallback, // 9.
+        &SQLTransaction::deliverStatementCallback,        // 10.
+        &SQLTransaction::deliverQuotaIncreaseCallback,    // 11.
+        &SQLTransaction::deliverSuccessCallback           // 12.
+    };
+
+    ASSERT(WTF_ARRAY_LENGTH(stateFunctions) == static_cast<int>(SQLTransactionState::NumberOfStates));
+    ASSERT(state < SQLTransactionState::NumberOfStates);
+
+    return stateFunctions[static_cast<int>(state)];
+}
+
+// requestTransitToState() can be called from the backend. Hence, it should
+// NOT be modifying SQLTransactionBackend in general. The only safe field to
+// modify is m_requestedState which is meant for this purpose.
+void SQLTransaction::requestTransitToState(SQLTransactionState nextState)
+{
+    LOG(StorageAPI, "Scheduling %s for transaction %p\n", nameForSQLTransactionState(nextState), this);
+    m_requestedState = nextState;
+    m_database->scheduleTransactionCallback(this);
+}
+
+SQLTransactionState SQLTransaction::nextStateForTransactionError()
+{
+    ASSERT(m_transactionError);
+    if (m_errorCallbackWrapper.hasCallback())
+        return SQLTransactionState::DeliverTransactionErrorCallback;
+
+    // No error callback, so fast-forward to:
+    // Transaction Step 11 - Rollback the transaction.
+    return SQLTransactionState::CleanupAfterTransactionErrorCallback;
+}
+
+SQLTransactionState SQLTransaction::deliverTransactionCallback()
+{
+    bool shouldDeliverErrorCallback = false;
+
+    // Spec 4.3.2 4: Invoke the transaction callback with the new SQLTransaction object
+    RefPtr<SQLTransactionCallback> callback = m_callbackWrapper.unwrap();
+    if (callback) {
+        m_executeSqlAllowed = true;
+        shouldDeliverErrorCallback = !callback->handleEvent(this);
+        m_executeSqlAllowed = false;
+    }
+
+    // Spec 4.3.2 5: If the transaction callback was null or raised an exception, jump to the error callback
+    SQLTransactionState nextState = SQLTransactionState::RunStatements;
+    if (shouldDeliverErrorCallback) {
+        m_database->reportStartTransactionResult(5, SQLError::UNKNOWN_ERR, 0);
+        m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the SQLTransactionCallback was null or threw an exception");
+        nextState = SQLTransactionState::DeliverTransactionErrorCallback;
+    }
+    m_database->reportStartTransactionResult(0, -1, 0); // OK
+    return nextState;
+}
+
+SQLTransactionState SQLTransaction::deliverTransactionErrorCallback()
+{
+    // Spec 4.3.2.10: If exists, invoke error callback with the last
+    // error to have occurred in this transaction.
+    RefPtr<SQLTransactionErrorCallback> errorCallback = m_errorCallbackWrapper.unwrap();
+    if (errorCallback) {
+        // If we get here with an empty m_transactionError, then the backend
+        // must be waiting in the idle state waiting for this state to finish.
+        // Hence, it's thread safe to fetch the backend transactionError without
+        // a lock.
+        if (!m_transactionError)
+            m_transactionError = m_backend->transactionError();
+
+        ASSERT(m_transactionError);
+        errorCallback->handleEvent(m_transactionError.get());
+
+        m_transactionError = 0;
+    }
+
+    clearCallbackWrappers();
+
+    // Spec 4.3.2.10: Rollback the transaction.
+    return SQLTransactionState::CleanupAfterTransactionErrorCallback;
+}
+
+SQLTransactionState SQLTransaction::deliverStatementCallback()
+{
+    ASSERT(m_backend->m_currentStatement);
+
+    // Spec 4.3.2.6.6 and 4.3.2.6.3: If the statement callback went wrong, jump to the transaction error callback
+    // Otherwise, continue to loop through the statement queue
+    m_executeSqlAllowed = true;
+    bool result = m_backend->m_currentStatement->performCallback(this);
+    m_executeSqlAllowed = false;
+
+    if (result) {
+        m_database->reportCommitTransactionResult(2, SQLError::UNKNOWN_ERR, 0);
+        m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the statement callback raised an exception or statement error callback did not return false");
+        return nextStateForTransactionError();
+    }
+    return SQLTransactionState::RunStatements;
+}
+
+SQLTransactionState SQLTransaction::deliverQuotaIncreaseCallback()
+{
+    ASSERT(m_backend->m_currentStatement);
+
+    bool shouldRetryCurrentStatement = m_database->transactionClient()->didExceedQuota(database());
+    m_backend->setShouldRetryCurrentStatement(shouldRetryCurrentStatement);
+
+    return SQLTransactionState::RunStatements;
+}
+
+SQLTransactionState SQLTransaction::deliverSuccessCallback()
+{
+    // Spec 4.3.2.8: Deliver success callback.
+    RefPtr<VoidCallback> successCallback = m_successCallbackWrapper.unwrap();
+    if (successCallback)
+        successCallback->handleEvent();
+
+    clearCallbackWrappers();
+
+    // Schedule a "post-success callback" step to return control to the database thread in case there
+    // are further transactions queued up for this Database
+    return SQLTransactionState::CleanupAndTerminate;
+}
+
+// This state function is used as a stub function to plug unimplemented states
+// in the state dispatch table. They are unimplemented because they should
+// never be reached in the course of correct execution.
+SQLTransactionState SQLTransaction::unreachableState()
+{
+    ASSERT_NOT_REACHED();
+    return SQLTransactionState::End;
+}
+
+SQLTransactionState SQLTransaction::sendToBackendState()
+{
+    ASSERT(m_nextState != SQLTransactionState::Idle);
+    m_backend->requestTransitToState(m_nextState);
+    return SQLTransactionState::Idle;
+}
+
+void SQLTransaction::performPendingCallback()
+{
+    LOG(StorageAPI, "Callback %s\n", nameForSQLTransactionState(m_nextState));
+
+    setStateToRequestedState();
+    ASSERT(m_nextState == SQLTransactionState::End
+        || m_nextState == SQLTransactionState::DeliverTransactionCallback
+        || m_nextState == SQLTransactionState::DeliverTransactionErrorCallback
+        || m_nextState == SQLTransactionState::DeliverStatementCallback
+        || m_nextState == SQLTransactionState::DeliverQuotaIncreaseCallback
+        || m_nextState == SQLTransactionState::DeliverSuccessCallback);
+
+    checkAndHandleClosedOrInterruptedDatabase();
+    runStateMachine();
+}
+
+void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
+{
+    if (!m_executeSqlAllowed || !m_database->opened()) {
+        e = INVALID_STATE_ERR;
+        return;
+    }
+
+    int permissions = DatabaseAuthorizer::ReadWriteMask;
+    if (!m_database->databaseContext()->allowDatabaseAccess())
+        permissions |= DatabaseAuthorizer::NoAccessMask;
+    else if (m_readOnly)
+        permissions |= DatabaseAuthorizer::ReadOnlyMask;
+
+    RefPtr<SQLStatement> statement = SQLStatement::create(m_database.get(), sqlStatement, arguments, callback, callbackError, permissions);
+
+    if (m_database->deleted())
+        statement->setDatabaseDeletedError(m_database.get());
+
+    m_backend->enqueueStatement(statement);
+}
+
+bool SQLTransaction::checkAndHandleClosedOrInterruptedDatabase()
+{
+    if (m_database->opened() && !m_database->isInterrupted())
+        return false;
+
+    clearCallbackWrappers();
+    m_nextState = SQLTransactionState::CleanupAndTerminate;
+
+    return true;
+}
+
+void SQLTransaction::clearCallbackWrappers()
+{
+    // Release the unneeded callbacks, to break reference cycles.
+    m_callbackWrapper.clear();
+    m_successCallbackWrapper.clear();
+    m_errorCallbackWrapper.clear();
 }
 

trunk/Source/WebCore/Modules/webdatabase/SQLTransaction.h

@@ -32 +32 @@
 #if ENABLE(SQL_DATABASE)
 
-#include "SQLTransactionBackend.h"
+#include "SQLCallbackWrapper.h"
+#include "SQLStatement.h"
+#include "SQLTransactionStateMachine.h"
+#include <wtf/PassRefPtr.h>
+#include <wtf/RefPtr.h>
 
 namespace WebCore {
 
-class SQLTransaction : public SQLTransactionBackend {
+class Database;
+class SQLError;
+class SQLStatementCallback;
+class SQLStatementErrorCallback;
+class SQLTransactionBackend;
+class SQLTransactionCallback;
+class SQLTransactionErrorCallback;
+class SQLValue;
+class VoidCallback;
+
+class SQLTransaction : public SQLTransactionStateMachine<SQLTransaction> {
 public:
-    static PassRefPtr<SQLTransaction> create(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
-                                             PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>, bool readOnly = false);
+    static PassRefPtr<SQLTransaction> create(Database*, PassRefPtr<SQLTransactionCallback>,
+        PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionErrorCallback>,
+        bool readOnly);
 
-    static SQLTransaction* from(SQLTransactionBackend*);
+    void setBackend(SQLTransactionBackend*);
+
+    void performPendingCallback();
+
+    void executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments,
+        PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, ExceptionCode&);
+
+    Database* database() { return m_database.get(); }
+
+    bool hasCallback() const { return m_callbackWrapper.hasCallback(); }
+    bool hasSuccessCallback() const { return m_successCallbackWrapper.hasCallback(); }
+    bool hasErrorCallback() const { return m_errorCallbackWrapper.hasCallback(); }
 
 private:
-    SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
-                   PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
+    SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>,
+        PassRefPtr<VoidCallback> successCallback, PassRefPtr<SQLTransactionErrorCallback>,
+        bool readOnly);
+
+    bool checkAndHandleClosedOrInterruptedDatabase();
+    void clearCallbackWrappers();
+
+    // State Machine functions:
+    virtual StateFunction stateFunctionFor(SQLTransactionState);
+    void requestTransitToState(SQLTransactionState);
+
+    // State functions:
+    SQLTransactionState deliverTransactionCallback();
+    SQLTransactionState deliverTransactionErrorCallback();
+    SQLTransactionState deliverStatementCallback();
+    SQLTransactionState deliverQuotaIncreaseCallback();
+    SQLTransactionState deliverSuccessCallback();
+
+    SQLTransactionState unreachableState();
+    SQLTransactionState sendToBackendState();
+
+    SQLTransactionState nextStateForTransactionError();
+
+    RefPtr<Database> m_database;
+    RefPtr<SQLTransactionBackend> m_backend;
+    SQLCallbackWrapper<SQLTransactionCallback> m_callbackWrapper;
+    SQLCallbackWrapper<VoidCallback> m_successCallbackWrapper;
+    SQLCallbackWrapper<SQLTransactionErrorCallback> m_errorCallbackWrapper;
+
+    bool m_executeSqlAllowed;
+    RefPtr<SQLError> m_transactionError;
+
+    bool m_readOnly;
+
+    friend class SQLTransactionBackend;
 };
 

trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.cpp

@@ -40 +40 @@
 #include "SQLError.h"
 #include "SQLStatement.h"
-#include "SQLStatementCallback.h"
-#include "SQLStatementErrorCallback.h"
+#include "SQLStatementCallback.h" // FIXME: remove when SQLStatement has been refactored.
+#include "SQLStatementErrorCallback.h" // FIXME: remove when SQLStatement has been refactored.
 #include "SQLTransaction.h"
-#include "SQLTransactionCallback.h"
 #include "SQLTransactionClient.h"
 #include "SQLTransactionCoordinator.h"
-#include "SQLTransactionErrorCallback.h"
 #include "SQLValue.h"
 #include "SQLiteTransaction.h"
-#include "ScriptExecutionContext.h"
-#include "VoidCallback.h"
-#include <wtf/OwnPtr.h>
-#include <wtf/PassRefPtr.h>
-#include <wtf/RefPtr.h>
+#include <wtf/StdLibExtras.h>
 #include <wtf/text/WTFString.h>
 
@@ -61 +55 @@
 // The SQLTransaction is a state machine that executes a series of states / steps.
 //
-// ths State Transition Graph at a glance:
+// The work of the transaction states are defined in section of 4.3.2 of the
+// webdatabase spec: http://dev.w3.org/html5/webdatabase/#processing-model
+//
+// the State Transition Graph at a glance:
 // ======================================
 //
-//    Backend (works with SQLiteDatabase)          .   Frontend (works with Script)
-//    ===================================          .   ============================
-//   ,--> State 0: [initial state]                 .
-//   | ^     v                                     .
-//   | |  State 1: [acquireLock]                   .
-//   | |     v                                     .
-//   | |  State 2: [openTransactionAndPreflight] ----------------------------------------------------.
-//   | |     |                                     .                                                 |
-//   | |     `---------------------------------------> State 3: [deliverTransactionCallback] -----.  |
-//   | |                                           .      |                                       v  v
-//   | |     ,--------------------------------------------'     State 10: [deliverTransactionErrorCallback] +
-//   | |     |                                     .                                              ^  ^  ^   |
-//   | |     v                                     .                                              |  |  |   |
-//   | |  State 4: [runStatements] ---------------------------------------------------------------'  |  |   |
-//   | |     |        ^  ^ |  ^ |                  .                                                 |  |   |
-//   | |     |--------'  | |  | `--------------------> State 8: [deliverStatementCallback] +---------'  |   |
-//   | |     |           | |  `------------------------------------------------------------'            |   |
-//   | |     |           | `-------------------------> State 9: [deliverQuotaIncreaseCallback] +        |   |
-//   | |     |            `--------------------------------------------------------------------'        |   |
-//   | |     v                                     .                                                    |   |
-//   | |  State 5: [postflightAndCommit] --+------------------------------------------------------------'   |
-//   | |                                   |---------> State 6: [deliverSuccessCallback] +                  |
-//   | |     ,-----------------------------'       .                                     |                  |
-//   | |     v                                     .                                     |                  |
-//   | |  State 7: [cleanupAfterSuccessCallback] <---------------------------------------'                  |
-//   | `-----'                                     .                                                        |
-//   `------------------------------------------------------------------------------------------------------'
-//                                                 .
+//     Backend                          .   Frontend
+//     (works with SQLiteDatabase)      .   (works with Script)
+//     ===========================      .   ===================
+//                                      .
+//     1. Idle                          .
+//         v                            .
+//     2. AcquireLock                   .
+//         v                            .
+//     3. OpenTransactionAndPreflight ------------------------------------------.
+//         |                            .                                       |
+//         `-------------------------------> 8. DeliverTransactionCallback --.  |
+//                                      .        |                           v  v
+//         ,-------------------------------------'   9. DeliverTransactionErrorCallback +
+//         |                            .                                    ^  ^  ^    |
+//         v                            .                                    |  |  |    |
+//     4. RunStatements -----------------------------------------------------'  |  |    |
+//         |        ^  ^ |  ^ |         .                                       |  |    |
+//         |--------'  | |  | `------------> 10. DeliverStatementCallback +-----'  |    |
+//         |           | |  `---------------------------------------------'        |    |
+//         |           | `-----------------> 11. DeliverQuotaIncreaseCallback +    |    |
+//         |            `-----------------------------------------------------'    |    |
+//         v                            .                                          |    |
+//     5. PostflightAndCommit --+--------------------------------------------------'    |
+//                              |----------> 12. DeliverSuccessCallback +               |
+//         ,--------------------'       .                               |               |
+//         v                            .                               |               |
+//     6. CleanupAndTerminate <-----------------------------------------'               |
+//         v           ^                .                                               |
+//     0. End          |                .                                               |
+//                     |                .                                               |
+//                7: CleanupAfterTransactionErrorCallback <----------------------------'
+//                                      .
 //
 // the States and State Transitions:
 // ================================
-// Executed in the back-end:
-//     State 0: [initial state]
-//     - On scheduled transaction, goto [acquireLock].
-//
-//     State 1: [acquireLock]
-//     - acquire lock.
-//     - on "lock" acquisition, goto [openTransactionAndPreflight].
-//
-//     State 2: [openTransactionAndPreflight]
-//     - Sets up an SQLiteTransaction.
-//     - begin the SQLiteTransaction.
-//     - call the SQLTransactionWrapper preflight if available.
-//     - schedule script callback.
-//     - on error (see handleTransactionError), goto [deliverTransactionErrorCallback].
-//     - goto [deliverTransactionCallback].
-//
-// Executed in the front-end:
-//     State 3: [deliverTransactionCallback]
-//     - invoke the script function callback() if available.
-//     - on error, goto [deliverTransactionErrorCallback].
-//     - goto [runStatements].
-//
-// Executed in the back-end:
-//     State 4: [runStatements]
-//     - while there are statements {
-//         - run a statement.
-//         - if statementCallback is available, goto [deliverStatementCallback].
-//         - on error,
-//           goto [deliverQuotaIncreaseCallback], or
-//           goto [deliverStatementCallback] (see handleCurrentStatementError), or
-//           goto [deliverTransactionErrorCallback].
-//       }
-//     - goto [postflightAndCommit].
-//
-//     State 5: [postflightAndCommit]
-//     - call the SQLTransactionWrapper postflight if available.
-//     - commit the SQLiteTansaction.
-//     - on error, goto [deliverTransactionErrorCallback] (see handleTransactionError).
-//     - if successCallback is available, goto [deliverSuccessCallback].
-//       else goto [cleanupAfterSuccessCallback].
-//
-// Executed in the front-end:
-//     State 6: [deliverSuccessCallback]
-//     - invoke the script function successCallback() if available.
-//     - goto [cleanupAfterSuccessCallback].
-//
-// Executed in the back-end:
-//     State 7: [cleanupAfterSuccessCallback]
-//     - clean the SQLiteTransaction.
-//     - release lock.
-//     - goto [initial state].
-//
-// Other states:
-// Executed in the front-end:
-//     State 8: [deliverStatementCallback]
-//     - invoke script statement callback (assume available).
-//     - on error (see handleTransactionError),
-//       goto [deliverTransactionErrorCallback].
-//     - goto [runStatements].
-//
-//     State 9: [deliverQuotaIncreaseCallback]
-//     - give client a chance to increase the quota.
-//     - goto [runStatements].
-//
-//     State 10: [deliverTransactionErrorCallback]
-//     - invoke the script function errorCallback if available.
-//     - goto [cleanupAfterTransactionErrorCallback].
-//
-// Executed in the back-end:
-//     State 11: [cleanupAfterTransactionErrorCallback]
-//     - rollback and clear SQLiteTransaction.
-//     - clear statements.
-//     - release lock.
-//     - goto [initial state].
+//     0. SQLTransactionState::End
+//         - the end state.
+//
+//     1. SQLTransactionState::Idle
+//         - placeholder state while waiting on frontend/backend, etc. See comment on
+//           "State transitions between SQLTransaction and SQLTransactionBackend"
+//           below.
+//
+//     2. SQLTransactionState::AcquireLock (runs in backend)
+//         - this is the start state.
+//         - acquire the "lock".
+//         - on "lock" acquisition, goto SQLTransactionState::OpenTransactionAndPreflight.
+//
+//     3. SQLTransactionState::openTransactionAndPreflight (runs in backend)
+//         - Sets up an SQLiteTransaction.
+//         - begin the SQLiteTransaction.
+//         - call the SQLTransactionWrapper preflight if available.
+//         - schedule script callback.
+//         - on error, goto SQLTransactionState::DeliverTransactionErrorCallback.
+//         - goto SQLTransactionState::DeliverTransactionCallback.
+//
+//     4. SQLTransactionState::DeliverTransactionCallback (runs in frontend)
+//         - invoke the script function callback() if available.
+//         - on error, goto SQLTransactionState::DeliverTransactionErrorCallback.
+//         - goto SQLTransactionState::RunStatements.
+//
+//     5. SQLTransactionState::DeliverTransactionErrorCallback (runs in frontend)
+//         - invoke the script function errorCallback if available.
+//         - goto SQLTransactionState::CleanupAfterTransactionErrorCallback.
+//
+//     6. SQLTransactionState::RunStatements (runs in backend)
+//         - while there are statements {
+//             - run a statement.
+//             - if statementCallback is available, goto SQLTransactionState::DeliverStatementCallback.
+//             - on error,
+//               goto SQLTransactionState::DeliverQuotaIncreaseCallback, or
+//               goto SQLTransactionState::DeliverStatementCallback, or
+//               goto SQLTransactionState::deliverTransactionErrorCallback.
+//           }
+//         - goto SQLTransactionState::PostflightAndCommit.
+//
+//     7. SQLTransactionState::DeliverStatementCallback (runs in frontend)
+//         - invoke script statement callback (assume available).
+//         - on error, goto SQLTransactionState::DeliverTransactionErrorCallback.
+//         - goto SQLTransactionState::RunStatements.
+//
+//     8. SQLTransactionState::DeliverQuotaIncreaseCallback (runs in frontend)
+//         - give client a chance to increase the quota.
+//         - goto SQLTransactionState::RunStatements.
+//
+//     9. SQLTransactionState::PostflightAndCommit (runs in backend)
+//         - call the SQLTransactionWrapper postflight if available.
+//         - commit the SQLiteTansaction.
+//         - on error, goto SQLTransactionState::DeliverTransactionErrorCallback.
+//         - if successCallback is available, goto SQLTransactionState::DeliverSuccessCallback.
+//           else goto SQLTransactionState::CleanupAndTerminate.
+//
+//     10. SQLTransactionState::DeliverSuccessCallback (runs in frontend)
+//         - invoke the script function successCallback() if available.
+//         - goto SQLTransactionState::CleanupAndTerminate.
+//
+//     11. SQLTransactionState::CleanupAndTerminate (runs in backend)
+//         - stop and clear the SQLiteTransaction.
+//         - release the "lock".
+//         - goto SQLTransactionState::End.
+//
+//     12. SQLTransactionState::CleanupAfterTransactionErrorCallback (runs in backend)
+//         - rollback the SQLiteTransaction.
+//         - goto SQLTransactionState::CleanupAndTerminate.
+//
+// State transitions between SQLTransaction and SQLTransactionBackend
+// ==================================================================
+// As shown above, there are state transitions that crosses the boundary between
+// the frontend and backend. For example,
+//
+//     OpenTransactionAndPreflight (state 3 in the backend)
+//     transitions to DeliverTransactionCallback (state 8 in the frontend),
+//     which in turn transitions to RunStatements (state 4 in the backend).
+//
+// This cross boundary transition is done by posting transition requests to the
+// other side and letting the other side's state machine execute the state
+// transition in the appropriate thread (i.e. the script thread for the frontend,
+// and the database thread for the backend).
+//
+// Logically, the state transitions work as shown in the graph above. But
+// physically, the transition mechanism uses the Idle state (both in the frontend
+// and backend) as a waiting state for further activity. For example, taking a
+// closer look at the 3 state transition example above, what actually happens
+// is as follows:
+//
+//     Step 1:
+//     ======
+//     In the frontend thread:
+//     - waiting quietly is Idle. Not doing any work.
+//
+//     In the backend:
+//     - is in OpenTransactionAndPreflight, and doing its work.
+//     - when done, it transits to the backend DeliverTransactionCallback.
+//     - the backend DeliverTransactionCallback sends a request to the frontend
+//       to transit to DeliverTransactionCallback, and then itself transits to
+//       Idle.
+//
+//     Step 2:
+//     ======
+//     In the frontend thread:
+//     - transits to DeliverTransactionCallback and does its work.
+//     - when done, it transits to the frontend RunStatements.
+//     - the frontend RunStatements sends a request to the backend to transit
+//       to RunStatements, and then itself transits to Idle.
+//
+//     In the backend:
+//     - waiting quietly in Idle.
+//
+//     Step 3:
+//     ======
+//     In the frontend thread:
+//     - waiting quietly is Idle. Not doing any work.
+//
+//     In the backend:
+//     - transits to RunStatements, and does its work.
+//        ...
+//
+// So, when the frontend or backend are not active, they will park themselves in
+// their Idle states. This means their m_nextState is set to Idle, but they never
+// actually run the corresponding state function. Note: for both the frontend and
+// backend, the state function for Idle is unreachableState().
+//
+// The states that send a request to their peer across the front/back boundary
+// are implemented with just 2 functions: SQLTransaction::sendToBackendState()
+// and SQLTransactionBackend::sendToFrontendState(). These state functions do
+// nothing but sends a request to the other side to transit to the current
+// state (indicated by m_nextState), and then transits itself to the Idle state
+// to wait for further action.
+
+
+// The Life-Cycle of a SQLTransaction i.e. Who's keeping the SQLTransactionAlive? 
+// =============================================================================
+// The RefPtr chain goes something like this:
+//
+//     At birth (in DatabaseBackendAsync::runTransaction()):
+//     ====================================================
+//     DatabaseBackendAsync               // in Deque<RefPtr<SQLTransactionBackend> > m_transactionQueue points to ...
+//     --> SQLTransactionBackend          // in RefPtr<SQLTransaction> m_frontend points to ...
+//         --> SQLTransaction             // in RefPtr<SQLTransactionBackend> m_backend points to ...
+//             --> SQLTransactionBackend  // which is a circular reference.
+//
+//     Note: there's a circular reference between the SQLTransaction front-end and
+//     back-end. This circular reference is established in the constructor of the
+//     SQLTransactionBackend. The circular reference will only be broken at the end
+//     of the transaction's clean up state i.e. when the transaction should no
+//     longer be in use thereafter.
+//
+//     After scheduling the transaction with the DatabaseThread (DatabaseBackendAsync::scheduleTransaction()):
+//     ======================================================================================================
+//     DatabaseThread                         // in MessageQueue<DatabaseTask> m_queue points to ...
+//     --> DatabaseTransactionTask            // in RefPtr<SQLTransactionBackend> m_transaction points to ...
+//         --> SQLTransactionBackend          // in RefPtr<SQLTransaction> m_frontend points to ...
+//             --> SQLTransaction             // in RefPtr<SQLTransactionBackend> m_backend points to ...
+//                 --> SQLTransactionBackend  // which is a circular reference.
+//
+//     When executing the transaction (in DatabaseThread::databaseThread()):
+//     ====================================================================
+//     OwnPtr<DatabaseTask> task;             // points to ...
+//     --> DatabaseTransactionTask            // in RefPtr<SQLTransactionBackend> m_transaction points to ...
+//         --> SQLTransactionBackend          // in: RefPtr<SQLTransaction> m_frontend;
+//             --> SQLTransaction             // in RefPtr<SQLTransactionBackend> m_backend points to ...
+//                 --> SQLTransactionBackend  // which is a circular reference.
+//
+//     At the end of cleanupAndTerminate():
+//     ===================================
+//     At the end of the cleanup state, the SQLTransactionBackend::m_frontend is nullified.
+//     If by then, a JSObject wrapper is referring to the SQLTransaction, then the reference
+//     chain looks like this:
+//
+//     JSObjectWrapper
+//     --> SQLTransaction             // in RefPtr<SQLTransactionBackend> m_backend points to ...
+//         --> SQLTransactionBackend  // which no longer points back to its SQLTransaction.
+//
+//     When the GC collects the corresponding JSObject, the above chain will be cleaned up
+//     and deleted.
+//
+//     If there is no JSObject wrapper referring to the SQLTransaction when the cleanup
+//     states nullify SQLTransactionBackend::m_frontend, the SQLTransaction will deleted then.
+//     However, there will still be a DatabaseTask pointing to the SQLTransactionBackend (see
+//     the "When executing the transaction" chain above). This will keep the
+//     SQLTransactionBackend alive until DatabaseThread::databaseThread() releases its
+//     task OwnPtr.
+//
+//     What happens if a transaction is interrupted?
+//     ============================================
+//     If the transaction is interrupted half way, it won't get to run to state
+//     CleanupAndTerminate, and hence, would not have called doCleanup(). doCleanup() is
+//     where we nullify SQLTransactionBackend::m_frontend to break the reference cycle
+//     between the frontend and backend. Hence, that transaction will never get cleaned
+//     up, unless ...
+//
+//     ... unless we have a cleanup mechanism for interruptions. That is, during the
+//     shutdown of the DatabaseThread, the SQLTransactionCoordinator will discover this
+//     interrupted transaction and invoke its notifyDatabaseThreadIsShuttingDown(),
+//     which in turn will call doCleanup(). With that, all is well again.
 
 
@@ -178 +305 @@
 namespace WebCore {
 
-SQLTransactionBackend::SQLTransactionBackend(Database* db, PassRefPtr<SQLTransactionCallback> callback,
-    PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback,
-    PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
-    : m_nextStep(&SQLTransactionBackend::acquireLock)
-    , m_executeSqlAllowed(false)
+PassRefPtr<SQLTransactionBackend> SQLTransactionBackend::create(DatabaseBackendAsync* db,
+    PassRefPtr<SQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
+{
+    return adoptRef(new SQLTransactionBackend(db, frontend, wrapper, readOnly));
+}
+
+SQLTransactionBackend::SQLTransactionBackend(DatabaseBackendAsync* db,
+    PassRefPtr<SQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
+    : m_frontend(frontend)
     , m_database(db)
     , m_wrapper(wrapper)
-    , m_callbackWrapper(callback, db->scriptExecutionContext())
-    , m_successCallbackWrapper(successCallback, db->scriptExecutionContext())
-    , m_errorCallbackWrapper(errorCallback, db->scriptExecutionContext())
+    , m_hasCallback(m_frontend->hasCallback())
+    , m_hasSuccessCallback(m_frontend->hasSuccessCallback())
+    , m_hasErrorCallback(m_frontend->hasErrorCallback())
     , m_shouldRetryCurrentStatement(false)
     , m_modifiedDatabase(false)
@@ -195 +326 @@
 {
     ASSERT(m_database);
+    m_frontend->setBackend(this);
+    m_requestedState = SQLTransactionState::AcquireLock;
 }
 
@@ -202 +335 @@
 }
 
-void SQLTransactionBackend::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
-{
-    if (!m_executeSqlAllowed || !m_database->opened()) {
-        e = INVALID_STATE_ERR;
-        return;
-    }
-
-    int permissions = DatabaseAuthorizer::ReadWriteMask;
-    if (!m_database->databaseContext()->allowDatabaseAccess())
-        permissions |= DatabaseAuthorizer::NoAccessMask;
-    else if (m_readOnly)
-        permissions |= DatabaseAuthorizer::ReadOnlyMask;
-
-    RefPtr<SQLStatement> statement = SQLStatement::create(m_database.get(), sqlStatement, arguments, callback, callbackError, permissions);
-
-    if (m_database->deleted())
-        statement->setDatabaseDeletedError(m_database.get());
-
-    enqueueStatement(statement);
+void SQLTransactionBackend::doCleanup()
+{
+    ASSERT(currentThread() == database()->databaseContext()->databaseThread()->getThreadID());
+
+    MutexLocker locker(m_statementMutex);
+    m_statementQueue.clear();
+
+    if (m_sqliteTransaction) {
+        // In the event we got here because of an interruption or error (i.e. if
+        // the transaction is in progress), we should roll it back here. Clearing
+        // m_sqliteTransaction invokes SQLiteTransaction's destructor which does
+        // just that. We might as well do this unconditionally and free up its
+        // resources because we're already terminating.
+        m_sqliteTransaction.clear();
+    }
+
+    // Release the lock on this database
+    if (m_lockAcquired)
+        m_database->transactionCoordinator()->releaseLock(this);
+
+    // Now that we're done, break the reference cycle that keeps us alive.
+    // See comment about the life-cycle above.
+    m_frontend = 0;
+
+    // Do some aggresive clean up here except for m_database.
+    //
+    // We can't clear m_database here because the frontend may asynchronously
+    // invoke SQLTransactionBackend::requestTransitToState(), and that function
+    // uses m_database to schedule a state transition. This may occur because
+    // the frontend (being in another thread) may already be on the way to
+    // requesting our next state before it detects an interruption.
+    //
+    // There is no harm in letting it finish making the request. It'll set
+    // m_requestedState, but we won't execute a transition to that state because
+    // we've already shut down the transaction.
+
+    m_currentStatement = 0;
+    m_wrapper = 0;
+    m_transactionError = 0;
+}
+
+PassRefPtr<SQLError> SQLTransactionBackend::transactionError()
+{
+    return m_transactionError;
+}
+
+void SQLTransactionBackend::setShouldRetryCurrentStatement(bool shouldRetry)
+{
+    ASSERT(!m_shouldRetryCurrentStatement);
+    m_shouldRetryCurrentStatement = shouldRetry;
+}
+
+SQLTransactionBackend::StateFunction SQLTransactionBackend::stateFunctionFor(SQLTransactionState state)
+{
+    static const StateFunction stateFunctions[] = {
+        &SQLTransactionBackend::unreachableState,            // 0. end
+        &SQLTransactionBackend::unreachableState,            // 1. idle
+        &SQLTransactionBackend::acquireLock,                 // 2.
+        &SQLTransactionBackend::openTransactionAndPreflight, // 3.
+        &SQLTransactionBackend::runStatements,               // 4.
+        &SQLTransactionBackend::postflightAndCommit,         // 5.
+        &SQLTransactionBackend::cleanupAndTerminate,         // 6.
+        &SQLTransactionBackend::cleanupAfterTransactionErrorCallback, // 7.
+        &SQLTransactionBackend::sendToFrontendState,         // 8. deliverTransactionCallback
+        &SQLTransactionBackend::sendToFrontendState,         // 9. deliverTransactionErrorCallback
+        &SQLTransactionBackend::sendToFrontendState,         // 10. deliverStatementCallback
+        &SQLTransactionBackend::sendToFrontendState,         // 11. deliverQuotaIncreaseCallback
+        &SQLTransactionBackend::sendToFrontendState          // 12. deliverSuccessCallback
+    };
+
+    ASSERT(WTF_ARRAY_LENGTH(stateFunctions) == static_cast<int>(SQLTransactionState::NumberOfStates));
+    ASSERT(state < SQLTransactionState::NumberOfStates);
+
+    return stateFunctions[static_cast<int>(state)];
 }
 
@@ -229 +417 @@
 }
 
-#if !LOG_DISABLED
-const char* SQLTransactionBackend::debugStepName(SQLTransactionBackend::TransactionStepMethod step)
-{
-    if (step == &SQLTransactionBackend::acquireLock)
-        return "acquireLock";
-    if (step == &SQLTransactionBackend::openTransactionAndPreflight)
-        return "openTransactionAndPreflight";
-    if (step == &SQLTransactionBackend::runStatements)
-        return "runStatements";
-    if (step == &SQLTransactionBackend::postflightAndCommit)
-        return "postflightAndCommit";
-    if (step == &SQLTransactionBackend::cleanupAfterTransactionErrorCallback)
-        return "cleanupAfterTransactionErrorCallback";
-    if (step == &SQLTransactionBackend::deliverTransactionCallback)
-        return "deliverTransactionCallback";
-    if (step == &SQLTransactionBackend::deliverTransactionErrorCallback)
-        return "deliverTransactionErrorCallback";
-    if (step == &SQLTransactionBackend::deliverStatementCallback)
-        return "deliverStatementCallback";
-    if (step == &SQLTransactionBackend::deliverQuotaIncreaseCallback)
-        return "deliverQuotaIncreaseCallback";
-    if (step == &SQLTransactionBackend::deliverSuccessCallback)
-        return "deliverSuccessCallback";
-    if (step == &SQLTransactionBackend::cleanupAfterSuccessCallback)
-        return "cleanupAfterSuccessCallback";
-    return "UNKNOWN";
-}
-#endif
-
 void SQLTransactionBackend::checkAndHandleClosedOrInterruptedDatabase()
 {
@@ -265 +424 @@
     // If the database was stopped, don't do anything and cancel queued work
     LOG(StorageAPI, "Database was stopped or interrupted - cancelling work for this transaction");
-    MutexLocker locker(m_statementMutex);
-    m_statementQueue.clear();
-    m_nextStep = 0;
-
-    // Release the unneeded callbacks, to break reference cycles.
-    m_callbackWrapper.clear();
-    m_successCallbackWrapper.clear();
-    m_errorCallbackWrapper.clear();
-
-    // The next steps should be executed only if we're on the DB thread.
-    if (currentThread() != database()->databaseContext()->databaseThread()->getThreadID())
-        return;
 
     // The current SQLite transaction should be stopped, as well
@@ -284 +431 @@
     }
 
-    if (m_lockAcquired)
-        m_database->transactionCoordinator()->releaseLock(this);
-}
-
-
-bool SQLTransactionBackend::performNextStep()
-{
-    LOG(StorageAPI, "Step %s\n", debugStepName(m_nextStep));
-
-    ASSERT(m_nextStep == &SQLTransactionBackend::acquireLock
-        || m_nextStep == &SQLTransactionBackend::openTransactionAndPreflight
-        || m_nextStep == &SQLTransactionBackend::runStatements
-        || m_nextStep == &SQLTransactionBackend::postflightAndCommit
-        || m_nextStep == &SQLTransactionBackend::cleanupAfterSuccessCallback
-        || m_nextStep == &SQLTransactionBackend::cleanupAfterTransactionErrorCallback);
+    // Terminate the frontend state machine. This also gets the frontend to
+    // call checkAndHandleClosedOrInterruptedDatabase() and clear its wrappers
+    // if needed.
+    m_frontend->requestTransitToState(SQLTransactionState::End);
+
+    // Redirect to the end state to abort, clean up, and end the transaction.
+    doCleanup();
+    m_nextState = SQLTransactionState::End;
+}
+
+void SQLTransactionBackend::performNextStep()
+{
+    LOG(StorageAPI, "State %s\n", nameForSQLTransactionState(m_nextState));
+
+    setStateToRequestedState();
+    ASSERT(m_nextState == SQLTransactionState::AcquireLock
+        || m_nextState == SQLTransactionState::OpenTransactionAndPreflight
+        || m_nextState == SQLTransactionState::RunStatements
+        || m_nextState == SQLTransactionState::PostflightAndCommit
+        || m_nextState == SQLTransactionState::CleanupAndTerminate
+        || m_nextState == SQLTransactionState::CleanupAfterTransactionErrorCallback);
 
     checkAndHandleClosedOrInterruptedDatabase();
-
-    if (m_nextStep)
-        (this->*m_nextStep)();
-
-    // If there is no nextStep after performing the above step, the transaction is complete
-    return !m_nextStep;
-}
-
-void SQLTransactionBackend::performPendingCallback()
-{
-    LOG(StorageAPI, "Callback %s\n", debugStepName(m_nextStep));
-
-    ASSERT(m_nextStep == &SQLTransactionBackend::deliverTransactionCallback
-        || m_nextStep == &SQLTransactionBackend::deliverTransactionErrorCallback
-        || m_nextStep == &SQLTransactionBackend::deliverStatementCallback
-        || m_nextStep == &SQLTransactionBackend::deliverQuotaIncreaseCallback
-        || m_nextStep == &SQLTransactionBackend::deliverSuccessCallback);
-
-    checkAndHandleClosedOrInterruptedDatabase();
-
-    if (m_nextStep)
-        (this->*m_nextStep)();
+    runStateMachine();
 }
 
@@ -329 +461 @@
     ASSERT(currentThread() == database()->databaseContext()->databaseThread()->getThreadID());
 
-    // If the transaction is in progress, we should roll it back here, since this is our last
-    // oportunity to do something related to this transaction on the DB thread.
-    // Clearing m_sqliteTransaction invokes SQLiteTransaction's destructor which does just that.
-    m_sqliteTransaction.clear();
-}
-
-void SQLTransactionBackend::acquireLock()
+    // If the transaction is in progress, we should roll it back here, since this
+    // is our last opportunity to do something related to this transaction on the
+    // DB thread. Amongst other work, doCleanup() will clear m_sqliteTransaction
+    // which invokes SQLiteTransaction's destructor, which will do the roll back
+    // if necessary.
+
+    // Note: if doCleanup() has already been invoked, then m_frontend would have
+    // been nullified.
+    if (m_frontend)
+        doCleanup();
+}
+
+SQLTransactionState SQLTransactionBackend::acquireLock()
 {
     m_database->transactionCoordinator()->acquireLock(this);
+    return SQLTransactionState::Idle;
 }
 
@@ -343 +482 @@
 {
     m_lockAcquired = true;
-    m_nextStep = &SQLTransactionBackend::openTransactionAndPreflight;
-    LOG(StorageAPI, "Scheduling openTransactionAndPreflight immediately for transaction %p\n", this);
-    m_database->scheduleTransactionStep(this, true);
-}
-
-void SQLTransactionBackend::openTransactionAndPreflight()
+    requestTransitToState(SQLTransactionState::OpenTransactionAndPreflight);
+}
+
+SQLTransactionState SQLTransactionBackend::openTransactionAndPreflight()
 {
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
@@ -356 +493 @@
 
     // If the database was deleted, jump to the error callback
-    if (m_database->deleted()) {
+    if (Database::from(m_database.get())->deleted()) {
         m_database->reportStartTransactionResult(1, SQLError::UNKNOWN_ERR, 0);
         m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unable to open a transaction, because the user deleted the database");
-        handleTransactionError(false);
-        return;
+        return nextStateForTransactionError();
     }
 
@@ -375 +511 @@
     m_database->enableAuthorizer();
 
-    // Transaction Steps 1+2 - Open a transaction to the database, jumping to the error callback if that fails
+    // Spec 4.3.2.1+2: Open a transaction to the database, jumping to the error callback if that fails
     if (!m_sqliteTransaction->inProgress()) {
         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
@@ -382 +518 @@
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         m_sqliteTransaction.clear();
-        handleTransactionError(false);
-        return;
+        return nextStateForTransactionError();
     }
 
@@ -397 +532 @@
         m_sqliteTransaction.clear();
         m_database->enableAuthorizer();
-        handleTransactionError(false);
-        return;
+        return nextStateForTransactionError();
     }
     m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
 
-    // Transaction Steps 3 - Peform preflight steps, jumping to the error callback if they fail
-    if (m_wrapper && !m_wrapper->performPreflight(SQLTransaction::from(this))) {
+    // Spec 4.3.2.3: Perform preflight steps, jumping to the error callback if they fail
+    if (m_wrapper && !m_wrapper->performPreflight(this)) {
         m_database->disableAuthorizer();
         m_sqliteTransaction.clear();
@@ -412 +546 @@
             m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction preflight");
         }
-        handleTransactionError(false);
-        return;
-    }
-
-    // Transaction Step 4 - Invoke the transaction callback with the new SQLTransaction object
-    m_nextStep = &SQLTransactionBackend::deliverTransactionCallback;
-    LOG(StorageAPI, "Scheduling deliverTransactionCallback for transaction %p\n", this);
-    m_database->scheduleTransactionCallback(SQLTransaction::from(this));
-}
-
-void SQLTransactionBackend::deliverTransactionCallback()
-{
-    bool shouldDeliverErrorCallback = false;
-
-    RefPtr<SQLTransactionCallback> callback = m_callbackWrapper.unwrap();
-    if (callback) {
-        m_executeSqlAllowed = true;
-        shouldDeliverErrorCallback = !callback->handleEvent(SQLTransaction::from(this));
-        m_executeSqlAllowed = false;
-    }
-
-    // Transaction Step 5 - If the transaction callback was null or raised an exception, jump to the error callback
-    if (shouldDeliverErrorCallback) {
-        m_database->reportStartTransactionResult(5, SQLError::UNKNOWN_ERR, 0);
-        m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the SQLTransactionCallback was null or threw an exception");
-        deliverTransactionErrorCallback();
-    } else
-        scheduleToRunStatements();
-
-    m_database->reportStartTransactionResult(0, -1, 0); // OK
-}
-
-void SQLTransactionBackend::scheduleToRunStatements()
-{
-    m_nextStep = &SQLTransactionBackend::runStatements;
-    LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
-    m_database->scheduleTransactionStep(this);
-}
-
-void SQLTransactionBackend::runStatements()
+        return nextStateForTransactionError();
+    }
+
+    // Spec 4.3.2.4: Invoke the transaction callback with the new SQLTransaction object
+    if (m_hasCallback)
+        return SQLTransactionState::DeliverTransactionCallback;
+
+    // If we have no callback to make, skip pass to the state after:
+    return SQLTransactionState::RunStatements;
+}
+
+SQLTransactionState SQLTransactionBackend::runStatements()
 {
     ASSERT(m_lockAcquired);
+    SQLTransactionState nextState;
 
     // If there is a series of statements queued up that are all successful and have no associated
@@ -472 +579 @@
             // that means it ended in an error. Handle it now
             if (m_currentStatement && m_currentStatement->lastExecutionFailedDueToQuota()) {
-                handleCurrentStatementError();
-                break;
+                return nextStateForCurrentStatementError();
             }
 
@@ -479 +585 @@
             getNextStatement();
         }
-    } while (runCurrentStatement());
-
-    // If runCurrentStatement() returned false, that means either there was no current statement to run,
-    // or the current statement requires a callback to complete. In the later case, it also scheduled
-    // the callback or performed any other additional work so we can return
-    if (!m_currentStatement)
-        postflightAndCommit();
+        nextState = runCurrentStatementAndGetNextState();
+    } while (nextState == SQLTransactionState::RunStatements);
+
+    return nextState;
 }
 
@@ -497 +600 @@
 }
 
-bool SQLTransactionBackend::runCurrentStatement()
-{
-    if (!m_currentStatement)
-        return false;
+SQLTransactionState SQLTransactionBackend::runCurrentStatementAndGetNextState()
+{
+    if (!m_currentStatement) {
+        // No more statements to run. So move on to the next state.
+        return SQLTransactionState::PostflightAndCommit;
+    }
 
     m_database->resetAuthorizer();
 
     if (m_hasVersionMismatch)
-        m_currentStatement->setVersionMismatchedError(m_database.get());
-
-    if (m_currentStatement->execute(m_database.get())) {
+        m_currentStatement->setVersionMismatchedError(Database::from(m_database.get()));
+
+    if (m_currentStatement->execute(Database::from(m_database.get()))) {
         if (m_database->lastActionChangedDatabase()) {
             // Flag this transaction as having changed the database for later delegate notification
             m_modifiedDatabase = true;
             // Also dirty the size of this database file for calculating quota usage
-            m_database->transactionClient()->didExecuteStatement(database());
+            m_database->transactionClient()->didExecuteStatement(Database::from(database()));
         }
 
         if (m_currentStatement->hasStatementCallback()) {
-            m_nextStep = &SQLTransactionBackend::deliverStatementCallback;
-            LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
-            m_database->scheduleTransactionCallback(SQLTransaction::from(this));
-            return false;
+            return SQLTransactionState::DeliverStatementCallback;
         }
-        return true;
+
+        // If we get here, then the statement doesn't have a callback to invoke.
+        // We can move on to the next statement. Hence, stay in this state.
+        return SQLTransactionState::RunStatements;
     }
 
     if (m_currentStatement->lastExecutionFailedDueToQuota()) {
-        m_nextStep = &SQLTransactionBackend::deliverQuotaIncreaseCallback;
-        LOG(StorageAPI, "Scheduling deliverQuotaIncreaseCallback for transaction %p\n", this);
-        m_database->scheduleTransactionCallback(SQLTransaction::from(this));
-        return false;
-    }
-
-    handleCurrentStatementError();
-
-    return false;
-}
-
-void SQLTransactionBackend::handleCurrentStatementError()
-{
-    // Transaction Steps 6.error - Call the statement's error callback, but if there was no error callback,
+        return SQLTransactionState::DeliverQuotaIncreaseCallback;
+    }
+
+    return nextStateForCurrentStatementError();
+}
+
+SQLTransactionState SQLTransactionBackend::nextStateForCurrentStatementError()
+{
+    // Spec 4.3.2.6.6: error - Call the statement's error callback, but if there was no error callback,
     // or the transaction was rolled back, jump to the transaction error callback
-    if (m_currentStatement->hasStatementErrorCallback() && !m_sqliteTransaction->wasRolledBackBySqlite()) {
-        m_nextStep = &SQLTransactionBackend::deliverStatementCallback;
-        LOG(StorageAPI, "Scheduling deliverStatementCallback for transaction %p\n", this);
-        m_database->scheduleTransactionCallback(SQLTransaction::from(this));
-    } else {
-        m_transactionError = m_currentStatement->sqlError();
-        if (!m_transactionError) {
-            m_database->reportCommitTransactionResult(1, SQLError::DATABASE_ERR, 0);
-            m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "the statement failed to execute");
-        }
-        handleTransactionError(false);
-    }
-}
-
-void SQLTransactionBackend::deliverStatementCallback()
-{
-    ASSERT(m_currentStatement);
-
-    // Transaction Step 6.6 and 6.3(error) - If the statement callback went wrong, jump to the transaction error callback
-    // Otherwise, continue to loop through the statement queue
-    m_executeSqlAllowed = true;
-    bool result = m_currentStatement->performCallback(SQLTransaction::from(this));
-    m_executeSqlAllowed = false;
-
-    if (result) {
-        m_database->reportCommitTransactionResult(2, SQLError::UNKNOWN_ERR, 0);
-        m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "the statement callback raised an exception or statement error callback did not return false");
-        handleTransactionError(true);
-    } else
-        scheduleToRunStatements();
-}
-
-void SQLTransactionBackend::deliverQuotaIncreaseCallback()
-{
-    ASSERT(m_currentStatement);
-    ASSERT(!m_shouldRetryCurrentStatement);
-
-    m_shouldRetryCurrentStatement = m_database->transactionClient()->didExceedQuota(database());
-
-    m_nextStep = &SQLTransactionBackend::runStatements;
-    LOG(StorageAPI, "Scheduling runStatements for transaction %p\n", this);
-    m_database->scheduleTransactionStep(this);
-}
-
-void SQLTransactionBackend::postflightAndCommit()
+    if (m_currentStatement->hasStatementErrorCallback() && !m_sqliteTransaction->wasRolledBackBySqlite())
+        return SQLTransactionState::DeliverStatementCallback;
+
+    m_transactionError = m_currentStatement->sqlError();
+    if (!m_transactionError) {
+        m_database->reportCommitTransactionResult(1, SQLError::DATABASE_ERR, 0);
+        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "the statement failed to execute");
+    }
+    return nextStateForTransactionError();
+}
+
+SQLTransactionState SQLTransactionBackend::postflightAndCommit()
 {
     ASSERT(m_lockAcquired);
 
-    // Transaction Step 7 - Peform postflight steps, jumping to the error callback if they fail
-    if (m_wrapper && !m_wrapper->performPostflight(SQLTransaction::from(this))) {
+    // Spec 4.3.2.7: Perform postflight steps, jumping to the error callback if they fail.
+    if (m_wrapper && !m_wrapper->performPostflight(this)) {
         m_transactionError = m_wrapper->sqlError();
         if (!m_transactionError) {
@@ -595 +662 @@
             m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction postflight");
         }
-        handleTransactionError(false);
-        return;
-    }
-
-    // Transacton Step 8+9 - Commit the transaction, jumping to the error callback if that fails
+        return nextStateForTransactionError();
+    }
+
+    // Spec 4.3.2.7: Commit the transaction, jumping to the error callback if that fails.
     ASSERT(m_sqliteTransaction);
 
@@ -609 +675 @@
     if (m_sqliteTransaction->inProgress()) {
         if (m_wrapper)
-            m_wrapper->handleCommitFailedAfterPostflight(SQLTransaction::from(this));
-        m_successCallbackWrapper.clear();
+            m_wrapper->handleCommitFailedAfterPostflight(this);
         m_database->reportCommitTransactionResult(4, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
         m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to commit transaction",
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
-        handleTransactionError(false);
-        return;
+        return nextStateForTransactionError();
     }
 
@@ -628 +692 @@
         m_database->transactionClient()->didCommitWriteTransaction(database());
 
-    // Now release our unneeded callbacks, to break reference cycles.
-    m_errorCallbackWrapper.clear();
-
-    // Transaction Step 10 - Deliver success callback, if there is one
-    if (m_successCallbackWrapper.hasCallback()) {
-        m_nextStep = &SQLTransactionBackend::deliverSuccessCallback;
-        LOG(StorageAPI, "Scheduling deliverSuccessCallback for transaction %p\n", this);
-        m_database->scheduleTransactionCallback(SQLTransaction::from(this));
-    } else
-        cleanupAfterSuccessCallback();
-}
-
-void SQLTransactionBackend::deliverSuccessCallback()
-{
-    // Transaction Step 10 - Deliver success callback
-    RefPtr<VoidCallback> successCallback = m_successCallbackWrapper.unwrap();
-    if (successCallback)
-        successCallback->handleEvent();
-
-    // Schedule a "post-success callback" step to return control to the database thread in case there
-    // are further transactions queued up for this Database
-    m_nextStep = &SQLTransactionBackend::cleanupAfterSuccessCallback;
-    LOG(StorageAPI, "Scheduling cleanupAfterSuccessCallback for transaction %p\n", this);
-    m_database->scheduleTransactionStep(this);
-}
-
-void SQLTransactionBackend::cleanupAfterSuccessCallback()
+    // Spec 4.3.2.8: Deliver success callback, if there is one.
+    return SQLTransactionState::DeliverSuccessCallback;
+}
+
+SQLTransactionState SQLTransactionBackend::cleanupAndTerminate()
 {
     ASSERT(m_lockAcquired);
 
-    // Transaction Step 11 - End transaction steps
-    // There is no next step
+    // Spec 4.3.2.9: End transaction steps. There is no next step.
     LOG(StorageAPI, "Transaction %p is complete\n", this);
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
-    m_sqliteTransaction.clear();
-    m_nextStep = 0;
-
-    // Release the lock on this database
-    m_database->transactionCoordinator()->releaseLock(this);
-}
-
-void SQLTransactionBackend::handleTransactionError(bool inCallback)
-{
-    if (m_errorCallbackWrapper.hasCallback()) {
-        if (inCallback)
-            deliverTransactionErrorCallback();
-        else {
-            m_nextStep = &SQLTransactionBackend::deliverTransactionErrorCallback;
-            LOG(StorageAPI, "Scheduling deliverTransactionErrorCallback for transaction %p\n", this);
-            m_database->scheduleTransactionCallback(SQLTransaction::from(this));
-        }
-        return;
-    }
-
-    // No error callback, so fast-forward to:
-    // Transaction Step 12 - Rollback the transaction.
-    if (inCallback) {
-        m_nextStep = &SQLTransactionBackend::cleanupAfterTransactionErrorCallback;
-        LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
-        m_database->scheduleTransactionStep(this);
-    } else
-        cleanupAfterTransactionErrorCallback();
-}
-
-void SQLTransactionBackend::deliverTransactionErrorCallback()
+
+    doCleanup();
+    m_database->inProgressTransactionCompleted();
+    return SQLTransactionState::End;
+}
+
+SQLTransactionState SQLTransactionBackend::nextStateForTransactionError()
 {
     ASSERT(m_transactionError);
-
-    // Transaction Step 12 - If exists, invoke error callback with the last
-    // error to have occurred in this transaction.
-    RefPtr<SQLTransactionErrorCallback> errorCallback = m_errorCallbackWrapper.unwrap();
-    if (errorCallback)
-        errorCallback->handleEvent(m_transactionError.get());
-
-    m_nextStep = &SQLTransactionBackend::cleanupAfterTransactionErrorCallback;
-    LOG(StorageAPI, "Scheduling cleanupAfterTransactionErrorCallback for transaction %p\n", this);
-    m_database->scheduleTransactionStep(this);
-}
-
-void SQLTransactionBackend::cleanupAfterTransactionErrorCallback()
+    if (m_hasErrorCallback)
+        return SQLTransactionState::DeliverTransactionErrorCallback;
+
+    // No error callback, so fast-forward to the next state and rollback the
+    // transaction.
+    return SQLTransactionState::CleanupAfterTransactionErrorCallback;
+}
+
+SQLTransactionState SQLTransactionBackend::cleanupAfterTransactionErrorCallback()
 {
     ASSERT(m_lockAcquired);
 
+    LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
     m_database->disableAuthorizer();
     if (m_sqliteTransaction) {
-        // Transaction Step 12 - Rollback the transaction.
+        // Spec 4.3.2.10: Rollback the transaction.
         m_sqliteTransaction->rollback();
 
@@ -721 +735 @@
     m_database->enableAuthorizer();
 
-    // Transaction Step 12 - Any still-pending statements in the transaction are discarded.
-    {
-        MutexLocker locker(m_statementMutex);
-        m_statementQueue.clear();
-    }
-
-    // Transaction is complete! There is no next step
-    LOG(StorageAPI, "Transaction %p is complete with an error\n", this);
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
-    m_nextStep = 0;
-
-    // Now release the lock on this database
-    m_database->transactionCoordinator()->releaseLock(this);
+
+    return SQLTransactionState::CleanupAndTerminate;
+}
+
+// requestTransitToState() can be called from the frontend. Hence, it should
+// NOT be modifying SQLTransactionBackend in general. The only safe field to
+// modify is m_requestedState which is meant for this purpose.
+void SQLTransactionBackend::requestTransitToState(SQLTransactionState nextState)
+{
+    LOG(StorageAPI, "Scheduling %s for transaction %p\n", nameForSQLTransactionState(nextState), this);
+    m_requestedState = nextState;
+    ASSERT(m_requestedState != SQLTransactionState::End);
+    m_database->scheduleTransactionStep(this);
+}
+
+// This state function is used as a stub function to plug unimplemented states
+// in the state dispatch table. They are unimplemented because they should
+// never be reached in the course of correct execution.
+SQLTransactionState SQLTransactionBackend::unreachableState()
+{
+    ASSERT_NOT_REACHED();
+    return SQLTransactionState::End;
+}
+
+SQLTransactionState SQLTransactionBackend::sendToFrontendState()
+{
+    ASSERT(m_nextState != SQLTransactionState::Idle);
+    m_frontend->requestTransitToState(m_nextState);
+    return SQLTransactionState::Idle;
 }
 

trunk/Source/WebCore/Modules/webdatabase/SQLTransactionBackend.h

@@ -33 +33 @@
 #include "DatabaseBasicTypes.h"
 #include "SQLStatement.h"
+#include "SQLTransactionStateMachine.h"
 #include <wtf/Deque.h>
 #include <wtf/Forward.h>
-#include <wtf/ThreadSafeRefCounted.h>
-#include <wtf/Vector.h>
 
 namespace WebCore {
 
-class Database;
+class DatabaseBackendAsync;
 class SQLError;
 class SQLiteTransaction;
-class SQLStatementCallback;
-class SQLStatementErrorCallback;
 class SQLTransaction;
-class SQLTransactionCallback;
-class SQLTransactionErrorCallback;
+class SQLTransactionBackend;
 class SQLValue;
-class VoidCallback;
 
 class SQLTransactionWrapper : public ThreadSafeRefCounted<SQLTransactionWrapper> {
 public:
     virtual ~SQLTransactionWrapper() { }
-    virtual bool performPreflight(SQLTransaction*) = 0;
-    virtual bool performPostflight(SQLTransaction*) = 0;
+    virtual bool performPreflight(SQLTransactionBackend*) = 0;
+    virtual bool performPostflight(SQLTransactionBackend*) = 0;
     virtual SQLError* sqlError() const = 0;
-    virtual void handleCommitFailedAfterPostflight(SQLTransaction*) = 0;
+    virtual void handleCommitFailedAfterPostflight(SQLTransactionBackend*) = 0;
 };
 
-class SQLTransactionBackend : public ThreadSafeRefCounted<SQLTransactionBackend> {
+class SQLTransactionBackend : public SQLTransactionStateMachine<SQLTransactionBackend> {
 public:
-    ~SQLTransactionBackend();
+    static PassRefPtr<SQLTransactionBackend> create(DatabaseBackendAsync*,
+        PassRefPtr<SQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
 
-    void executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments,
-        PassRefPtr<SQLStatementCallback>, PassRefPtr<SQLStatementErrorCallback>, ExceptionCode&);
+    virtual ~SQLTransactionBackend();
 
     void lockAcquired();
-    bool performNextStep();
-    void performPendingCallback();
+    void performNextStep();
 
-    Database* database() { return m_database.get(); }
+    DatabaseBackendAsync* database() { return m_database.get(); }
     bool isReadOnly() { return m_readOnly; }
     void notifyDatabaseThreadIsShuttingDown();
 
+    PassRefPtr<SQLError> transactionError();
+    void setShouldRetryCurrentStatement(bool);
+
 private:
-    SQLTransactionBackend(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>,
-        PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
+    SQLTransactionBackend(DatabaseBackendAsync*, PassRefPtr<SQLTransaction>,
+        PassRefPtr<SQLTransactionWrapper>, bool readOnly);
 
-    typedef void (SQLTransactionBackend::*TransactionStepMethod)();
-    TransactionStepMethod m_nextStep;
+    void doCleanup();
 
     void enqueueStatement(PassRefPtr<SQLStatement>);
@@ -86 +82 @@
     void checkAndHandleClosedOrInterruptedDatabase();
 
-    void acquireLock();
-    void openTransactionAndPreflight();
-    void deliverTransactionCallback();
-    void scheduleToRunStatements();
-    void runStatements();
+    // State Machine functions:
+    virtual StateFunction stateFunctionFor(SQLTransactionState);
+    void requestTransitToState(SQLTransactionState);
+
+    // State functions:
+    SQLTransactionState acquireLock();
+    SQLTransactionState openTransactionAndPreflight();
+    SQLTransactionState runStatements();
+    SQLTransactionState postflightAndCommit();
+    SQLTransactionState cleanupAndTerminate();
+    SQLTransactionState cleanupAfterTransactionErrorCallback();
+
+    SQLTransactionState unreachableState();
+    SQLTransactionState sendToFrontendState();
+
+    SQLTransactionState nextStateForCurrentStatementError();
+    SQLTransactionState nextStateForTransactionError();
+    SQLTransactionState runCurrentStatementAndGetNextState();
+
     void getNextStatement();
-    bool runCurrentStatement();
-    void handleCurrentStatementError();
-    void deliverStatementCallback();
-    void deliverQuotaIncreaseCallback();
-    void postflightAndCommit();
-    void deliverSuccessCallback();
-    void cleanupAfterSuccessCallback();
-    void handleTransactionError(bool inCallback);
-    void deliverTransactionErrorCallback();
-    void cleanupAfterTransactionErrorCallback();
 
-#if !LOG_DISABLED
-    static const char* debugStepName(TransactionStepMethod);
-#endif
-
+    RefPtr<SQLTransaction> m_frontend;
     RefPtr<SQLStatement> m_currentStatement;
 
-    bool m_executeSqlAllowed;
+    RefPtr<DatabaseBackendAsync> m_database;
+    RefPtr<SQLTransactionWrapper> m_wrapper;
+    RefPtr<SQLError> m_transactionError;
 
-    RefPtr<Database> m_database;
-    RefPtr<SQLTransactionWrapper> m_wrapper;
-    SQLCallbackWrapper<SQLTransactionCallback> m_callbackWrapper;
-    SQLCallbackWrapper<VoidCallback> m_successCallbackWrapper;
-    SQLCallbackWrapper<SQLTransactionErrorCallback> m_errorCallbackWrapper;
-    RefPtr<SQLError> m_transactionError;
+    bool m_hasCallback;
+    bool m_hasSuccessCallback;
+    bool m_hasErrorCallback;
     bool m_shouldRetryCurrentStatement;
     bool m_modifiedDatabase;
@@ -128 +124 @@
     OwnPtr<SQLiteTransaction> m_sqliteTransaction;
 
-    friend class SQLTransaction; // FIXME: Remove this once the front-end has been properly isolated.
+    friend class SQLTransaction;
 };
 

trunk/Source/WebCore/Modules/webdatabase/SQLTransactionClient.cpp

@@ -37 +37 @@
 #include "DatabaseBackendContext.h"
 #include "DatabaseManager.h"
+#include "DatabaseTracker.h"
 #include "ScriptExecutionContext.h"
 #include "SecurityOrigin.h"
@@ -44 +45 @@
 void SQLTransactionClient::didCommitWriteTransaction(DatabaseBackend* database)
 {
-    DatabaseManager::manager().scheduleNotifyDatabaseChanged(
+    DatabaseTracker::tracker().scheduleNotifyDatabaseChanged(
         database->securityOrigin(), database->stringIdentifier());
 }
@@ -50 +51 @@
 void SQLTransactionClient::didExecuteStatement(DatabaseBackend* database)
 {
-    DatabaseManager::manager().databaseChanged(database);
+    DatabaseTracker::tracker().databaseChanged(database);
 }
 

trunk/Source/WebCore/Modules/webdatabase/SQLTransactionCoordinator.cpp

@@ -35 +35 @@
 #if ENABLE(SQL_DATABASE)
 
-#include "Database.h"
+#include "DatabaseBackendAsync.h"
 #include "SQLTransactionBackend.h"
 #include <wtf/Deque.h>
@@ -46 +46 @@
 static String getDatabaseIdentifier(SQLTransactionBackend* transaction)
 {
-    Database* database = transaction->database();
+    DatabaseBackendAsync* database = transaction->database();
     ASSERT(database);
     return database->stringIdentifier();

trunk/Source/WebCore/Target.pri

@@ -1456 +1456 @@
     \
     Modules/webdatabase/AbstractDatabaseServer.h \
+    Modules/webdatabase/ChangeVersionData.h \
     Modules/webdatabase/ChangeVersionWrapper.h \
     Modules/webdatabase/DOMWindowWebDatabase.h \
@@ -1486 +1487 @@
     Modules/webdatabase/SQLTransactionClient.h \
     Modules/webdatabase/SQLTransactionCoordinator.h \
+    Modules/webdatabase/SQLTransactionState.h \
+    Modules/webdatabase/SQLTransactionStateMachine.h \
     Modules/webdatabase/SQLTransactionSync.h \
     Modules/webdatabase/SQLTransactionSyncCallback.h \
@@ -3075 +3078 @@
         Modules/webdatabase/SQLTransactionClient.cpp \
         Modules/webdatabase/SQLTransactionCoordinator.cpp \
+        Modules/webdatabase/SQLTransactionStateMachine.cpp \
         Modules/webdatabase/SQLTransactionSync.cpp \
 

trunk/Source/WebCore/WebCore.gypi

@@ -985 +985 @@
             'Modules/webaudio/WaveTable.h',
             'Modules/webdatabase/AbstractDatabaseServer.h',
+            'Modules/webdatabase/ChangeVersionData.h',
             'Modules/webdatabase/ChangeVersionWrapper.cpp',
             'Modules/webdatabase/ChangeVersionWrapper.h',
@@ -1040 +1041 @@
             'Modules/webdatabase/SQLTransactionCoordinator.cpp',
             'Modules/webdatabase/SQLTransactionCoordinator.h',
+            'Modules/webdatabase/SQLTransactionState.h',
+            'Modules/webdatabase/SQLTransactionStateMachine.cpp',
+            'Modules/webdatabase/SQLTransactionStateMachine.h',
             'Modules/webdatabase/SQLTransactionSync.cpp',
             'Modules/webdatabase/SQLTransactionSync.h',

trunk/Source/WebCore/WebCore.vcproj/WebCore.vcproj

@@ -25379 +25379 @@
                                 </File>
                                 <File
+                                        RelativePath="..\Modules\webdatabase\ChangeVersionData.h"
+                                        >
+                                </File>
+                                <File
                                         RelativePath="..\Modules\webdatabase\ChangeVersionWrapper.cpp"
                                         >
@@ -25636 +25640 @@
                                 <File
                                         RelativePath="..\Modules\webdatabase\SQLTransactionErrorCallback.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\Modules\webdatabase\SQLTransactionState.h"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\Modules\webdatabase\SQLTransactionStateMachine.cpp"
+                                        >
+                                </File>
+                                <File
+                                        RelativePath="..\Modules\webdatabase\SQLTransactionStateMachine.h"
                                         >
                                 </File>

trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj

@@ -1881 +1881 @@
     <ClCompile Include="..\Modules\webdatabase\SQLTransactionClient.cpp" />
     <ClCompile Include="..\Modules\webdatabase\SQLTransactionCoordinator.cpp" />
+    <ClCompile Include="..\Modules\webdatabase\SQLTransactionStateMachine.cpp" />
     <ClCompile Include="..\Modules\webdatabase\SQLTransactionSync.cpp" />
     <ClCompile Include="..\Modules\webdatabase\WorkerContextWebDatabase.cpp" />
@@ -6416 +6417 @@
     <ClInclude Include="..\Modules\notifications\WorkerContextNotifications.h" />
     <ClInclude Include="..\Modules\webdatabase\AbstractDatabaseServer.h" />
+    <ClInclude Include="..\Modules\webdatabase\ChangeVersionData.h" />
     <ClInclude Include="..\Modules\webdatabase\ChangeVersionWrapper.h" />
     <ClInclude Include="..\Modules\webdatabase\Database.h" />
@@ -6453 +6455 @@
     <ClInclude Include="..\Modules\webdatabase\SQLTransactionCoordinator.h" />
     <ClInclude Include="..\Modules\webdatabase\SQLTransactionErrorCallback.h" />
+    <ClInclude Include="..\Modules\webdatabase\SQLTransactionState.h" />
+    <ClInclude Include="..\Modules\webdatabase\SQLTransactionStateMachine.h" />
     <ClInclude Include="..\Modules\webdatabase\SQLTransactionSync.h" />
     <ClInclude Include="..\Modules\webdatabase\SQLTransactionSyncCallback.h" />

trunk/Source/WebCore/WebCore.vcxproj/WebCore.vcxproj.filters

@@ -1900 +1900 @@
       <Filter>Modules\webdatabase</Filter>
     </ClCompile>
-    <ClCompile Include="..\Modules\webdatabase\SQLTransaction.cpp">
-      <Filter>Modules\webdatabase</Filter>
-    </ClCompile>
     <ClCompile Include="..\Modules\webdatabase\SQLTransactionBackend.cpp">
       <Filter>Modules\webdatabase</Filter>
@@ -1913 +1910 @@
     </ClCompile>
     <ClCompile Include="..\Modules\webdatabase\SQLTransactionCoordinator.cpp">
+      <Filter>Modules\webdatabase</Filter>
+    </ClCompile>
+    <ClCompile Include="..\Modules\webdatabase\SQLTransactionStateMachine.cpp">
       <Filter>Modules\webdatabase</Filter>
     </ClCompile>
@@ -8473 +8473 @@
       <Filter>Modules\webdatabase</Filter>
     </ClInclude>
+    <ClInclude Include="..\Modules\webdatabase\ChangeVersionData.h">
+      <Filter>Modules\webdatabase</Filter>
+    </ClInclude>
     <ClInclude Include="..\Modules\webdatabase\ChangeVersionWrapper.h">
       <Filter>Modules\webdatabase</Filter>
@@ -8582 +8585 @@
     </ClInclude>
     <ClInclude Include="..\Modules\webdatabase\SQLTransactionErrorCallback.h">
+      <Filter>Modules\webdatabase</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Modules\webdatabase\SQLTransactionState.h">
+      <Filter>Modules\webdatabase</Filter>
+    </ClInclude>
+    <ClInclude Include="..\Modules\webdatabase\SQLTransactionStateMachine.h">
       <Filter>Modules\webdatabase</Filter>
     </ClInclude>

trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -3707 +3707 @@
                 97BC69DA1505F076001B74AC /* DatabaseBackend.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC69D61505F076001B74AC /* DatabaseBackend.cpp */; };
                 97BC69DB1505F076001B74AC /* DatabaseBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC69D71505F076001B74AC /* DatabaseBackend.h */; settings = {ATTRIBUTES = (Private, ); }; };
+                FE36FD1516C7826500F887C1 /* ChangeVersionData.h in Headers */ = {isa = PBXBuildFile; fileRef = FE36FD1116C7826400F887C1 /* ChangeVersionData.h */; };
                 97BC69DC1505F076001B74AC /* ChangeVersionWrapper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC69D81505F076001B74AC /* ChangeVersionWrapper.cpp */; };
                 97BC69DD1505F076001B74AC /* ChangeVersionWrapper.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC69D91505F076001B74AC /* ChangeVersionWrapper.h */; };
@@ -3746 +3747 @@
                 97BC6A4F1505F081001B74AC /* SQLTransaction.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC6A0D1505F081001B74AC /* SQLTransaction.cpp */; };
                 97BC6A501505F081001B74AC /* SQLTransaction.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC6A0E1505F081001B74AC /* SQLTransaction.h */; };
+                FEE1811316C319E800084849 /* SQLTransactionBackend.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEE1811116C319E800084849 /* SQLTransactionBackend.cpp */; };
+                FEE1811416C319E800084849 /* SQLTransactionBackend.h in Headers */ = {isa = PBXBuildFile; fileRef = FEE1811216C319E800084849 /* SQLTransactionBackend.h */; };
+                FEAD7D8716C339EE00D4670B /* SQLTransactionBackendSync.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FEAD7D8516C339EE00D4670B /* SQLTransactionBackendSync.cpp */; };
+                FEAD7D8816C339EE00D4670B /* SQLTransactionBackendSync.h in Headers */ = {isa = PBXBuildFile; fileRef = FEAD7D8616C339EE00D4670B /* SQLTransactionBackendSync.h */; };
                 97BC6A521505F081001B74AC /* SQLTransactionCallback.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC6A101505F081001B74AC /* SQLTransactionCallback.h */; };
                 97BC6A541505F081001B74AC /* SQLTransactionClient.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC6A121505F081001B74AC /* SQLTransactionClient.cpp */; };
@@ -3752 +3757 @@
                 97BC6A571505F081001B74AC /* SQLTransactionCoordinator.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC6A151505F081001B74AC /* SQLTransactionCoordinator.h */; };
                 97BC6A581505F081001B74AC /* SQLTransactionErrorCallback.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC6A161505F081001B74AC /* SQLTransactionErrorCallback.h */; };
+                FE36FD1816C7826500F887C1 /* SQLTransactionState.h in Headers */ = {isa = PBXBuildFile; fileRef = FE36FD1416C7826400F887C1 /* SQLTransactionState.h */; };
+                FE36FD1616C7826500F887C1 /* SQLTransactionStateMachine.cpp in Sources */ = {isa = PBXBuildFile; fileRef = FE36FD1216C7826400F887C1 /* SQLTransactionStateMachine.cpp */; };
+                FE36FD1716C7826500F887C1 /* SQLTransactionStateMachine.h in Headers */ = {isa = PBXBuildFile; fileRef = FE36FD1316C7826400F887C1 /* SQLTransactionStateMachine.h */; };
                 97BC6A5A1505F081001B74AC /* SQLTransactionSync.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 97BC6A181505F081001B74AC /* SQLTransactionSync.cpp */; };
                 97BC6A5B1505F081001B74AC /* SQLTransactionSync.h in Headers */ = {isa = PBXBuildFile; fileRef = 97BC6A191505F081001B74AC /* SQLTransactionSync.h */; };
@@ -11158 +11166 @@
                 97BC69D61505F076001B74AC /* DatabaseBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DatabaseBackend.cpp; path = Modules/webdatabase/DatabaseBackend.cpp; sourceTree = "<group>"; };
                 97BC69D71505F076001B74AC /* DatabaseBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DatabaseBackend.h; path = Modules/webdatabase/DatabaseBackend.h; sourceTree = "<group>"; };
+                FE36FD1116C7826400F887C1 /* ChangeVersionData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ChangeVersionData.h; path = Modules/webdatabase/ChangeVersionData.h; sourceTree = "<group>"; };
                 97BC69D81505F076001B74AC /* ChangeVersionWrapper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ChangeVersionWrapper.cpp; path = Modules/webdatabase/ChangeVersionWrapper.cpp; sourceTree = "<group>"; };
                 97BC69D91505F076001B74AC /* ChangeVersionWrapper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = ChangeVersionWrapper.h; path = Modules/webdatabase/ChangeVersionWrapper.h; sourceTree = "<group>"; };
@@ -11207 +11216 @@
                 97BC6A0E1505F081001B74AC /* SQLTransaction.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransaction.h; path = Modules/webdatabase/SQLTransaction.h; sourceTree = "<group>"; };
                 97BC6A0F1505F081001B74AC /* SQLTransaction.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = SQLTransaction.idl; path = Modules/webdatabase/SQLTransaction.idl; sourceTree = "<group>"; };
+                FEE1811116C319E800084849 /* SQLTransactionBackend.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SQLTransactionBackend.cpp; path = Modules/webdatabase/SQLTransactionBackend.cpp; sourceTree = "<group>"; };
+                FEE1811216C319E800084849 /* SQLTransactionBackend.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionBackend.h; path = Modules/webdatabase/SQLTransactionBackend.h; sourceTree = "<group>"; };
+                FEAD7D8516C339EE00D4670B /* SQLTransactionBackendSync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SQLTransactionBackendSync.cpp; path = Modules/webdatabase/SQLTransactionBackendSync.cpp; sourceTree = "<group>"; };
+                FEAD7D8616C339EE00D4670B /* SQLTransactionBackendSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionBackendSync.h; path = Modules/webdatabase/SQLTransactionBackendSync.h; sourceTree = "<group>"; };
                 97BC6A101505F081001B74AC /* SQLTransactionCallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionCallback.h; path = Modules/webdatabase/SQLTransactionCallback.h; sourceTree = "<group>"; };
                 97BC6A111505F081001B74AC /* SQLTransactionCallback.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = SQLTransactionCallback.idl; path = Modules/webdatabase/SQLTransactionCallback.idl; sourceTree = "<group>"; };
@@ -11215 +11228 @@
                 97BC6A161505F081001B74AC /* SQLTransactionErrorCallback.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionErrorCallback.h; path = Modules/webdatabase/SQLTransactionErrorCallback.h; sourceTree = "<group>"; };
                 97BC6A171505F081001B74AC /* SQLTransactionErrorCallback.idl */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = SQLTransactionErrorCallback.idl; path = Modules/webdatabase/SQLTransactionErrorCallback.idl; sourceTree = "<group>"; };
+                FE36FD1416C7826400F887C1 /* SQLTransactionState.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionState.h; path = Modules/webdatabase/SQLTransactionState.h; sourceTree = "<group>"; };
+                FE36FD1216C7826400F887C1 /* SQLTransactionStateMachine.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SQLTransactionStateMachine.cpp; path = Modules/webdatabase/SQLTransactionStateMachine.cpp; sourceTree = "<group>"; };
+                FE36FD1316C7826400F887C1 /* SQLTransactionStateMachine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionStateMachine.h; path = Modules/webdatabase/SQLTransactionStateMachine.h; sourceTree = "<group>"; };
                 97BC6A181505F081001B74AC /* SQLTransactionSync.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SQLTransactionSync.cpp; path = Modules/webdatabase/SQLTransactionSync.cpp; sourceTree = "<group>"; };
                 97BC6A191505F081001B74AC /* SQLTransactionSync.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SQLTransactionSync.h; path = Modules/webdatabase/SQLTransactionSync.h; sourceTree = "<group>"; };
@@ -18616 +18632 @@
                         children = (
                                 FE115FA9167988CD00249134 /* AbstractDatabaseServer.h */,
+                                FE36FD1116C7826400F887C1 /* ChangeVersionData.h */,
                                 97BC69D81505F076001B74AC /* ChangeVersionWrapper.cpp */,
                                 97BC69D91505F076001B74AC /* ChangeVersionWrapper.h */,
@@ -18696 +18713 @@
                                 97BC6A161505F081001B74AC /* SQLTransactionErrorCallback.h */,
                                 97BC6A171505F081001B74AC /* SQLTransactionErrorCallback.idl */,
+                                FE36FD1416C7826400F887C1 /* SQLTransactionState.h */,
+                                FE36FD1216C7826400F887C1 /* SQLTransactionStateMachine.cpp */,
+                                FE36FD1316C7826400F887C1 /* SQLTransactionStateMachine.h */,
                                 97BC6A181505F081001B74AC /* SQLTransactionSync.cpp */,
                                 97BC6A191505F081001B74AC /* SQLTransactionSync.h */,
@@ -23314 +23334 @@
                                 079D086B162F21F900DB8658 /* CaptionUserPreferencesMac.h in Headers */,
                                 6550B69E099DF0270090D781 /* CDATASection.h in Headers */,
+                                FE36FD1516C7826500F887C1 /* ChangeVersionData.h in Headers */,
                                 97BC69DD1505F076001B74AC /* ChangeVersionWrapper.h in Headers */,
                                 FD315FFF12B0267600C1A359 /* ChannelMergerNode.h in Headers */,
@@ -25928 +25949 @@
                                 97BC6A571505F081001B74AC /* SQLTransactionCoordinator.h in Headers */,
                                 97BC6A581505F081001B74AC /* SQLTransactionErrorCallback.h in Headers */,
+                                FE36FD1816C7826500F887C1 /* SQLTransactionState.h in Headers */,
+                                FE36FD1716C7826500F887C1 /* SQLTransactionStateMachine.h in Headers */,
                                 97BC6A5B1505F081001B74AC /* SQLTransactionSync.h in Headers */,
                                 97BC6A5D1505F081001B74AC /* SQLTransactionSyncCallback.h in Headers */,
@@ -29226 +29249 @@
                                 97BC6A541505F081001B74AC /* SQLTransactionClient.cpp in Sources */,
                                 97BC6A561505F081001B74AC /* SQLTransactionCoordinator.cpp in Sources */,
+                                FE36FD1616C7826500F887C1 /* SQLTransactionStateMachine.cpp in Sources */,
                                 97BC6A5A1505F081001B74AC /* SQLTransactionSync.cpp in Sources */,
                                 1A2E6E590CC55213004A2062 /* SQLValue.cpp in Sources */,

trunk/Source/WebCore/inspector/InspectorDatabaseAgent.cpp

@@ -42 +42 @@
 #include "InstrumentingAgents.h"
 #include "SQLError.h"
+#include "SQLResultSet.h"
+#include "SQLResultSetRowList.h"
 #include "SQLStatementCallback.h"
 #include "SQLStatementErrorCallback.h"
-#include "SQLResultSetRowList.h"
 #include "SQLTransaction.h"
 #include "SQLTransactionCallback.h"