Web SQL: Remove unnecessary abstraction.

Source/modules/webdatabase/SQLTransaction.h

 /*
  * Copyright (C) 2007, 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 12 matching lines @@
  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef SQLTransaction_h
 #define SQLTransaction_h
 
 #include "bindings/core/v8/ScriptWrappable.h"
-#include "modules/webdatabase/AbstractSQLTransaction.h"
 #include "modules/webdatabase/SQLCallbackWrapper.h"
 #include "modules/webdatabase/SQLStatement.h"
 #include "modules/webdatabase/SQLTransactionStateMachine.h"
 #include "platform/heap/Handle.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
-class AbstractSQLTransactionBackend;
 class Database;
 class ExceptionState;
 class SQLErrorData;
 class SQLStatementCallback;
 class SQLStatementErrorCallback;
+class SQLTransactionBackend;
 class SQLTransactionCallback;
 class SQLTransactionErrorCallback;
 class SQLValue;
 class VoidCallback;
 
-class SQLTransaction FINAL : public AbstractSQLTransaction, public SQLTransactionStateMachine<SQLTransaction>, public ScriptWrappable {
+class SQLTransaction FINAL
+    : public ThreadSafeRefCountedWillBeGarbageCollectedFinalized<SQLTransaction>
+    , public SQLTransactionStateMachine<SQLTransaction>
+    , public ScriptWrappable {
     DEFINE_WRAPPERTYPEINFO();
 public:
     static PassRefPtrWillBeRawPtr<SQLTransaction> create(Database*, PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
         PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
         bool readOnly);
-    virtual void trace(Visitor*) OVERRIDE;
+    ~SQLTransaction();
+    void trace(Visitor*);
 
     void performPendingCallback();
 
     void executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments,
         PassOwnPtrWillBeRawPtr<SQLStatementCallback>, PassOwnPtrWillBeRawPtr<SQLStatementErrorCallback>, ExceptionState&);
 
     Database* database() { return m_database.get(); }
 
     PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> releaseErrorCallback();
 
+    // APIs called from the backend published:
+    void requestTransitToState(SQLTransactionState);
+    bool hasCallback() const;
+    bool hasSuccessCallback() const;
+    bool hasErrorCallback() const;
+    void setBackend(SQLTransactionBackend*);
+
 private:
     SQLTransaction(Database*, PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
         PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
         bool readOnly);
 
     void clearCallbackWrappers();
 
-    // APIs called from the backend published via AbstractSQLTransaction:
-    virtual void requestTransitToState(SQLTransactionState) OVERRIDE;
-    virtual bool hasCallback() const OVERRIDE;
-    virtual bool hasSuccessCallback() const OVERRIDE;
-    virtual bool hasErrorCallback() const OVERRIDE;
-    virtual void setBackend(AbstractSQLTransactionBackend*) OVERRIDE;
-
     // State Machine functions:
     virtual StateFunction stateFunctionFor(SQLTransactionState) OVERRIDE;
     bool computeNextStateAndCleanupIfNeeded();
 
     // State functions:
     SQLTransactionState deliverTransactionCallback();
     SQLTransactionState deliverTransactionErrorCallback();
     SQLTransactionState deliverStatementCallback();
     SQLTransactionState deliverQuotaIncreaseCallback();
     SQLTransactionState deliverSuccessCallback();
 
     SQLTransactionState unreachableState();
     SQLTransactionState sendToBackendState();
 
     SQLTransactionState nextStateForTransactionError();
 
     RefPtrWillBeMember<Database> m_database;
-    RefPtrWillBeMember<AbstractSQLTransactionBackend> m_backend;
+    RefPtrWillBeMember<SQLTransactionBackend> m_backend;
     SQLCallbackWrapper<SQLTransactionCallback> m_callbackWrapper;
     SQLCallbackWrapper<VoidCallback> m_successCallbackWrapper;
     SQLCallbackWrapper<SQLTransactionErrorCallback> m_errorCallbackWrapper;
 
     bool m_executeSqlAllowed;
     OwnPtr<SQLErrorData> m_transactionError;
 
     bool m_readOnly;
 };
 
 } // namespace blink
 
 #endif // SQLTransaction_h