Oilpan: Prepare to move AbstractSQLTransactionBackend, SQLTransactionBackend, and SQLTransactionCoo…

Source/modules/webdatabase/SQLTransactionBackend.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 39 matching lines @@
 
 class SQLTransactionWrapper : public ThreadSafeRefCounted<SQLTransactionWrapper> {
 public:
     virtual ~SQLTransactionWrapper() { }
     virtual bool performPreflight(SQLTransactionBackend*) = 0;
     virtual bool performPostflight(SQLTransactionBackend*) = 0;
     virtual SQLError* sqlError() const = 0;
     virtual void handleCommitFailedAfterPostflight(SQLTransactionBackend*) = 0;
 };
 
-class SQLTransactionBackend FINAL : public SQLTransactionStateMachine<SQLTransactionBackend>, public AbstractSQLTransactionBackend {
+class SQLTransactionBackend FINAL : public AbstractSQLTransactionBackend, public SQLTransactionStateMachine<SQLTransactionBackend> {
 public:
-    static PassRefPtr<SQLTransactionBackend> create(DatabaseBackend*,
+    static PassRefPtrWillBeRawPtr<SQLTransactionBackend> create(DatabaseBackend*,
         PassRefPtrWillBeRawPtr<AbstractSQLTransaction>, PassRefPtr<SQLTransactionWrapper>, bool readOnly);
 
     virtual ~SQLTransactionBackend();
+    virtual void trace(Visitor*) OVERRIDE;
 
     void lockAcquired();
     void performNextStep();
 
     DatabaseBackend* database() { return m_database.get(); }
     bool isReadOnly() { return m_readOnly; }
     void notifyDatabaseThreadIsShuttingDown();
 
 private:
     SQLTransactionBackend(DatabaseBackend*, PassRefPtrWillBeRawPtr<AbstractSQLTransaction>,
@@ skipping 25 matching lines @@
 
     SQLTransactionState unreachableState();
     SQLTransactionState sendToFrontendState();
 
     SQLTransactionState nextStateForCurrentStatementError();
     SQLTransactionState nextStateForTransactionError();
     SQLTransactionState runCurrentStatementAndGetNextState();
 
     void getNextStatement();
 
-    RefPtrWillBeCrossThreadPersistent<AbstractSQLTransaction> m_frontend; // Has a reference cycle, and will break in doCleanup().
+    RefPtrWillBeMember<AbstractSQLTransaction> m_frontend; // Has a reference cycle, and will break in doCleanup().

[haraken, 2014/03/19 04:59:20]

Who guarantees that the thread that created the SQLTransaction is alive while
the database thread is holding the SQLTransaction?

I think it's safe to store "an on-heap object created from one thread" into "a
member of another thread" only if it's guaranteed that the creation thread
outlives the thread that holds the member. Is there any way to assert the
guarantee?

[tkent, 2014/03/19 05:15:13]

It's guaranteed.  A main/worker thread creates a dedicated database thread, and
it waits for  the database thread termination at [1].

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...

     RefPtr<SQLStatementBackend> m_currentStatementBackend;
 
-    RefPtrWillBeCrossThreadPersistent<DatabaseBackend> m_database;
+    RefPtrWillBeMember<DatabaseBackend> m_database;
     RefPtr<SQLTransactionWrapper> m_wrapper;
     RefPtr<SQLError> m_transactionError;
 
     bool m_hasCallback;
     bool m_hasSuccessCallback;
     bool m_hasErrorCallback;
     bool m_shouldRetryCurrentStatement;
     bool m_modifiedDatabase;
     bool m_lockAcquired;
     bool m_readOnly;
     bool m_hasVersionMismatch;
 
     Mutex m_statementMutex;
     Deque<RefPtr<SQLStatementBackend> > m_statementQueue;
 
     OwnPtr<SQLiteTransaction> m_sqliteTransaction;
 };
 
 } // namespace WebCore
 
 #endif // SQLTransactionBackend_h