Web SQL: Remove unnecessary abstraction.

Source/modules/webdatabase/SQLTransaction.cpp

 /*
  * Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 15 matching lines @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "modules/webdatabase/SQLTransaction.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/html/VoidCallback.h"
 #include "platform/Logging.h"
-#include "modules/webdatabase/AbstractSQLTransactionBackend.h"
 #include "modules/webdatabase/Database.h"
 #include "modules/webdatabase/DatabaseAuthorizer.h"
 #include "modules/webdatabase/DatabaseContext.h"
 #include "modules/webdatabase/SQLError.h"
 #include "modules/webdatabase/SQLStatementCallback.h"
 #include "modules/webdatabase/SQLStatementErrorCallback.h"
+#include "modules/webdatabase/SQLTransactionBackend.h"
 #include "modules/webdatabase/SQLTransactionCallback.h"
 #include "modules/webdatabase/SQLTransactionClient.h" // FIXME: Should be used in the backend only.
 #include "modules/webdatabase/SQLTransactionErrorCallback.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 PassRefPtrWillBeRawPtr<SQLTransaction> SQLTransaction::create(Database* db, PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
     PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
     bool readOnly)
 {
     return adoptRefWillBeNoop(new SQLTransaction(db, callback, successCallback, errorCallback, readOnly));
 }
 
 SQLTransaction::SQLTransaction(Database* db, PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
     PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
     bool readOnly)
     : m_database(db)
     , m_callbackWrapper(callback, db->executionContext())
     , m_successCallbackWrapper(successCallback, db->executionContext())
     , m_errorCallbackWrapper(errorCallback, db->executionContext())
     , m_executeSqlAllowed(false)
     , m_readOnly(readOnly)
 {
     ASSERT(m_database);
 }
 
+SQLTransaction::~SQLTransaction()
+{
+}
+
 void SQLTransaction::trace(Visitor* visitor)
 {
     visitor->trace(m_database);
     visitor->trace(m_backend);
     visitor->trace(m_callbackWrapper);
     visitor->trace(m_successCallbackWrapper);
     visitor->trace(m_errorCallbackWrapper);
-    AbstractSQLTransaction::trace(visitor);
 }
 
 bool SQLTransaction::hasCallback() const
 {
     return m_callbackWrapper.hasCallback();
 }
 
 bool SQLTransaction::hasSuccessCallback() const
 {
     return m_successCallbackWrapper.hasCallback();
 }
 
 bool SQLTransaction::hasErrorCallback() const
 {
     return m_errorCallbackWrapper.hasCallback();
 }
 
-void SQLTransaction::setBackend(AbstractSQLTransactionBackend* backend)
+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
@@ skipping 86 matching lines @@
     // Spec 4.3.2.10: Rollback the transaction.
     return SQLTransactionState::CleanupAfterTransactionErrorCallback;
 }
 
 SQLTransactionState SQLTransaction::deliverStatementCallback()
 {
     // 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;
 
-    AbstractSQLStatement* currentAbstractStatement = m_backend->currentStatement();
-    SQLStatement* currentStatement = static_cast<SQLStatement*>(currentAbstractStatement);
+    SQLStatement* currentStatement = m_backend->currentStatement();
     ASSERT(currentStatement);
 
     bool result = currentStatement->performCallback(this);
 
     m_executeSqlAllowed = false;
 
     if (result) {
         m_database->reportCommitTransactionResult(2, SQLError::UNKNOWN_ERR, 0);
         m_transactionError = SQLErrorData::create(SQLError::UNKNOWN_ERR, "the statement callback raised an exception or statement error callback did not return false");
         return nextStateForTransactionError();
@@ skipping 99 matching lines @@
     m_successCallbackWrapper.clear();
     m_errorCallbackWrapper.clear();
 }
 
 PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> SQLTransaction::releaseErrorCallback()
 {
     return m_errorCallbackWrapper.unwrap();
 }
 
 } // namespace blink