Oilpan: Prepare to move AbstractSQLTransactionBackend, SQLTransactionBackend,...

Oilpan: Prepare to move AbstractSQLTransactionBackend, SQLTransactionBackend, and SQLTransactionCoordinator::CoordinationInfo to Oilpan heap.

This CL changes the mapped type of m_coordinationInfoMap from copyable
object to OwnPtr<> or Member<>. So we need to update some code
in SQLTransactionCoordinator.

BUG=347902
R=ager@chromium.org, haraken@chromium.org

Review URL: https://codereview.chromium.org/198213005

git-svn-id: svn://svn.chromium.org/blink/trunk@169535 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/heap/Handle.h

@@ -430,7 +430,6 @@ public:
     Member(T* raw) : m_raw(raw)
     {
         COMPILE_ASSERT_IS_GARBAGE_COLLECTED(T, NonGarbageCollectedObjectInMember);
-        ASSERT(!raw || ThreadStateFor<ThreadingTrait<T>::Affinity>::state()->contains(raw));
     }
 
     Member(WTF::HashTableDeletedValueType) : m_raw(reinterpret_cast<T*>(-1))

third_party/WebKit/Source/modules/webdatabase/AbstractSQLTransactionBackend.h

@@ -26,6 +26,7 @@
 #ifndef AbstractSQLTransactionBackend_h
 #define AbstractSQLTransactionBackend_h
 
+#include "heap/Handle.h"
 #include "modules/webdatabase/sqlite/SQLValue.h"
 #include "modules/webdatabase/AbstractSQLStatement.h"
 #include "modules/webdatabase/SQLError.h"
@@ -37,9 +38,10 @@
 
 namespace WebCore {
 
-class AbstractSQLTransactionBackend : public ThreadSafeRefCounted<AbstractSQLTransactionBackend> {
+class AbstractSQLTransactionBackend : public ThreadSafeRefCountedWillBeGarbageCollectedFinalized<AbstractSQLTransactionBackend> {
 public:
     virtual ~AbstractSQLTransactionBackend() { }
+    virtual void trace(Visitor*) = 0;
 
     virtual void requestTransitToState(SQLTransactionState) = 0;
 

third_party/WebKit/Source/modules/webdatabase/Database.cpp

@@ -144,7 +144,7 @@ void Database::runTransaction(PassOwnPtr<SQLTransactionCallback> callback, PassO
     SQLTransactionErrorCallback* originalErrorCallback = errorCallback.get();
 #endif
     RefPtrWillBeRawPtr<SQLTransaction> transaction = SQLTransaction::create(this, callback, successCallback, errorCallback, readOnly);
-    RefPtr<SQLTransactionBackend> transactionBackend = backend()->runTransaction(transaction, readOnly, changeVersionData);
+    RefPtrWillBeRawPtr<SQLTransactionBackend> transactionBackend = backend()->runTransaction(transaction, readOnly, changeVersionData);
     if (!transactionBackend) {
         OwnPtr<SQLTransactionErrorCallback> callback = transaction->releaseErrorCallback();
         ASSERT(callback == originalErrorCallback);

third_party/WebKit/Source/modules/webdatabase/DatabaseBackend.cpp

@@ -49,6 +49,7 @@ DatabaseBackend::DatabaseBackend(PassRefPtr<DatabaseContext> databaseContext, co
 
 void DatabaseBackend::trace(Visitor* visitor)
 {
+    visitor->trace(m_transactionQueue);
     DatabaseBackendBase::trace(visitor);
 }
 
@@ -90,7 +91,7 @@ void DatabaseBackend::close()
         // Clean up transactions that have not been scheduled yet:
         // Transaction phase 1 cleanup. See comment on "What happens if a
         // transaction is interrupted?" at the top of SQLTransactionBackend.cpp.
-        RefPtr<SQLTransactionBackend> transaction;
+        RefPtrWillBeRawPtr<SQLTransactionBackend> transaction;
         while (!m_transactionQueue.isEmpty()) {
             transaction = m_transactionQueue.takeFirst();
             transaction->notifyDatabaseThreadIsShuttingDown();
@@ -104,7 +105,7 @@ void DatabaseBackend::close()
     databaseContext()->databaseThread()->recordDatabaseClosed(this);
 }
 
-PassRefPtr<SQLTransactionBackend> DatabaseBackend::runTransaction(PassRefPtrWillBeRawPtr<SQLTransaction> transaction,
+PassRefPtrWillBeRawPtr<SQLTransactionBackend> DatabaseBackend::runTransaction(PassRefPtrWillBeRawPtr<SQLTransaction> transaction,
     bool readOnly, const ChangeVersionData* data)
 {
     MutexLocker locker(m_transactionInProgressMutex);
@@ -115,7 +116,7 @@ PassRefPtr<SQLTransactionBackend> DatabaseBackend::runTransaction(PassRefPtrWill
     if (data)
         wrapper = ChangeVersionWrapper::create(data->oldVersion(), data->newVersion());
 
-    RefPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, transaction, wrapper, readOnly);
+    RefPtrWillBeRawPtr<SQLTransactionBackend> transactionBackend = SQLTransactionBackend::create(this, transaction, wrapper, readOnly);
     m_transactionQueue.append(transactionBackend);
     if (!m_transactionInProgress)
         scheduleTransaction();
@@ -133,7 +134,7 @@ void DatabaseBackend::inProgressTransactionCompleted()
 void DatabaseBackend::scheduleTransaction()
 {
     ASSERT(!m_transactionInProgressMutex.tryLock()); // Locked by caller.
-    RefPtr<SQLTransactionBackend> transaction;
+    RefPtrWillBeRawPtr<SQLTransactionBackend> transaction;
 
     if (m_isTransactionQueueEnabled && !m_transactionQueue.isEmpty())
         transaction = m_transactionQueue.takeFirst();

third_party/WebKit/Source/modules/webdatabase/DatabaseBackend.h

@@ -54,7 +54,7 @@ public:
     virtual bool openAndVerifyVersion(bool setVersionInNewDatabase, DatabaseError&, String& errorMessage) OVERRIDE FINAL;
     void close();
 
-    PassRefPtr<SQLTransactionBackend> runTransaction(PassRefPtrWillBeRawPtr<SQLTransaction>, bool readOnly, const ChangeVersionData*);
+    PassRefPtrWillBeRawPtr<SQLTransactionBackend> runTransaction(PassRefPtrWillBeRawPtr<SQLTransaction>, bool readOnly, const ChangeVersionData*);
     void scheduleTransactionStep(SQLTransactionBackend*);
     void inProgressTransactionCompleted();
 
@@ -71,7 +71,7 @@ private:
 
     void scheduleTransaction();
 
-    Deque<RefPtr<SQLTransactionBackend> > m_transactionQueue;
+    Deque<RefPtrWillBeMember<SQLTransactionBackend> > m_transactionQueue;
     Mutex m_transactionInProgressMutex;
     bool m_transactionInProgress;
     bool m_isTransactionQueueEnabled;

third_party/WebKit/Source/modules/webdatabase/DatabaseTask.cpp

@@ -157,7 +157,7 @@ const char* DatabaseBackend::DatabaseCloseTask::debugTaskName() const
 // *** DatabaseTransactionTask ***
 // Starts a transaction that will report its results via a callback.
 
-DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend> transaction)
+DatabaseBackend::DatabaseTransactionTask::DatabaseTransactionTask(PassRefPtrWillBeRawPtr<SQLTransactionBackend> transaction)
     : DatabaseTask(Database::from(transaction->database()), 0)
     , m_transaction(transaction)
 {

third_party/WebKit/Source/modules/webdatabase/DatabaseTask.h

@@ -142,7 +142,7 @@ public:
     virtual ~DatabaseTransactionTask();
 
     // Transaction task is never synchronous, so no 'synchronizer' parameter.
-    static PassOwnPtr<DatabaseTransactionTask> create(PassRefPtr<SQLTransactionBackend> transaction)
+    static PassOwnPtr<DatabaseTransactionTask> create(PassRefPtrWillBeRawPtr<SQLTransactionBackend> transaction)
     {
         return adoptPtr(new DatabaseTransactionTask(transaction));
     }
@@ -150,7 +150,7 @@ public:
     SQLTransactionBackend* transaction() const { return m_transaction.get(); }
 
 private:
-    explicit DatabaseTransactionTask(PassRefPtr<SQLTransactionBackend>);
+    explicit DatabaseTransactionTask(PassRefPtrWillBeRawPtr<SQLTransactionBackend>);
 
     virtual void doPerformTask() OVERRIDE;
     virtual void taskCancelled() OVERRIDE;
@@ -158,7 +158,7 @@ private:
     virtual const char* debugTaskName() const OVERRIDE;
 #endif
 
-    RefPtr<SQLTransactionBackend> m_transaction;
+    RefPtrWillBeCrossThreadPersistent<SQLTransactionBackend> m_transaction;
 };
 
 class DatabaseBackend::DatabaseTableNamesTask FINAL : public DatabaseTask {

third_party/WebKit/Source/modules/webdatabase/SQLTransaction.cpp

@@ -72,6 +72,7 @@ SQLTransaction::SQLTransaction(Database* db, PassOwnPtr<SQLTransactionCallback>
 void SQLTransaction::trace(Visitor* visitor)
 {
     visitor->trace(m_database);
+    visitor->trace(m_backend);
 }
 
 bool SQLTransaction::hasCallback() const

third_party/WebKit/Source/modules/webdatabase/SQLTransaction.h

@@ -98,7 +98,7 @@ private:
     SQLTransactionState nextStateForTransactionError();
 
     RefPtrWillBeMember<Database> m_database;
-    RefPtr<AbstractSQLTransactionBackend> m_backend;
+    RefPtrWillBeMember<AbstractSQLTransactionBackend> m_backend;
     SQLCallbackWrapper<SQLTransactionCallback> m_callbackWrapper;
     SQLCallbackWrapper<VoidCallback> m_successCallbackWrapper;
     SQLCallbackWrapper<SQLTransactionErrorCallback> m_errorCallbackWrapper;

third_party/WebKit/Source/modules/webdatabase/SQLTransactionBackend.cpp

@@ -340,10 +340,10 @@
 
 namespace WebCore {
 
-PassRefPtr<SQLTransactionBackend> SQLTransactionBackend::create(DatabaseBackend* db,
+PassRefPtrWillBeRawPtr<SQLTransactionBackend> SQLTransactionBackend::create(DatabaseBackend* db,
     PassRefPtrWillBeRawPtr<AbstractSQLTransaction> frontend, PassRefPtr<SQLTransactionWrapper> wrapper, bool readOnly)
 {
-    return adoptRef(new SQLTransactionBackend(db, frontend, wrapper, readOnly));
+    return adoptRefWillBeNoop(new SQLTransactionBackend(db, frontend, wrapper, readOnly));
 }
 
 SQLTransactionBackend::SQLTransactionBackend(DatabaseBackend* db,
@@ -370,6 +370,12 @@ SQLTransactionBackend::~SQLTransactionBackend()
     ASSERT(!m_sqliteTransaction);
 }
 
+void SQLTransactionBackend::trace(Visitor* visitor)
+{
+    visitor->trace(m_frontend);
+    visitor->trace(m_database);
+}
+
 void SQLTransactionBackend::doCleanup()
 {
     if (!m_frontend)

third_party/WebKit/Source/modules/webdatabase/SQLTransactionBackend.h

@@ -57,12 +57,13 @@ public:
     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();
@@ -108,10 +109,10 @@ private:
 
     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().
     RefPtr<SQLStatementBackend> m_currentStatementBackend;
 
-    RefPtrWillBeCrossThreadPersistent<DatabaseBackend> m_database;
+    RefPtrWillBeMember<DatabaseBackend> m_database;
     RefPtr<SQLTransactionWrapper> m_wrapper;
     RefPtr<SQLError> m_transactionError;
 

third_party/WebKit/Source/modules/webdatabase/SQLTransactionCoordinator.cpp

@@ -54,7 +54,7 @@ void SQLTransactionCoordinator::processPendingTransactions(CoordinationInfo& inf
     if (info.activeWriteTransaction || info.pendingTransactions.isEmpty())
         return;
 
-    RefPtr<SQLTransactionBackend> firstPendingTransaction = info.pendingTransactions.first();
+    RefPtrWillBeRawPtr<SQLTransactionBackend> firstPendingTransaction = info.pendingTransactions.first();
     if (firstPendingTransaction->isReadOnly()) {
         do {
             firstPendingTransaction = info.pendingTransactions.takeFirst();
@@ -74,7 +74,7 @@ void SQLTransactionCoordinator::acquireLock(SQLTransactionBackend* transaction)
 
     String dbIdentifier = getDatabaseIdentifier(transaction);
 
-    CoordinationInfoMap::iterator coordinationInfoIterator = m_coordinationInfoMap.find(dbIdentifier);
+    CoordinationInfoHeapMap::iterator coordinationInfoIterator = m_coordinationInfoMap.find(dbIdentifier);
     if (coordinationInfoIterator == m_coordinationInfoMap.end()) {
         // No pending transactions for this DB
         CoordinationInfo& info = m_coordinationInfoMap.add(dbIdentifier, CoordinationInfo()).storedValue->value;
@@ -95,7 +95,7 @@ void SQLTransactionCoordinator::releaseLock(SQLTransactionBackend* transaction)
 
     String dbIdentifier = getDatabaseIdentifier(transaction);
 
-    CoordinationInfoMap::iterator coordinationInfoIterator = m_coordinationInfoMap.find(dbIdentifier);
+    CoordinationInfoHeapMap::iterator coordinationInfoIterator = m_coordinationInfoMap.find(dbIdentifier);
     ASSERT_WITH_SECURITY_IMPLICATION(coordinationInfoIterator != m_coordinationInfoMap.end());
     CoordinationInfo& info = coordinationInfoIterator->value;
 
@@ -117,7 +117,7 @@ void SQLTransactionCoordinator::shutdown()
     m_isShuttingDown = true;
 
     // Notify all transactions in progress that the database thread is shutting down
-    for (CoordinationInfoMap::iterator coordinationInfoIterator = m_coordinationInfoMap.begin();
+    for (CoordinationInfoHeapMap::iterator coordinationInfoIterator = m_coordinationInfoMap.begin();
          coordinationInfoIterator != m_coordinationInfoMap.end(); ++coordinationInfoIterator) {
         CoordinationInfo& info = coordinationInfoIterator->value;
 
@@ -126,7 +126,7 @@ void SQLTransactionCoordinator::shutdown()
         // transaction is interrupted?" at the top of SQLTransactionBackend.cpp.
         if (info.activeWriteTransaction)
             info.activeWriteTransaction->notifyDatabaseThreadIsShuttingDown();
-        for (HashSet<RefPtr<SQLTransactionBackend> >::iterator activeReadTransactionsIterator =
+        for (WillBeHeapHashSet<RefPtrWillBeMember<SQLTransactionBackend> >::iterator activeReadTransactionsIterator =
                      info.activeReadTransactions.begin();
              activeReadTransactionsIterator != info.activeReadTransactions.end();
              ++activeReadTransactionsIterator) {
@@ -137,7 +137,7 @@ void SQLTransactionCoordinator::shutdown()
         // Transaction phase 3 cleanup. See comment on "What happens if a
         // transaction is interrupted?" at the top of SQLTransactionBackend.cpp.
         while (!info.pendingTransactions.isEmpty()) {
-            RefPtr<SQLTransactionBackend> transaction = info.pendingTransactions.first();
+            RefPtrWillBeRawPtr<SQLTransactionBackend> transaction = info.pendingTransactions.first();
             transaction->notifyDatabaseThreadIsShuttingDown();
         }
     }

third_party/WebKit/Source/modules/webdatabase/SQLTransactionCoordinator.h

@@ -32,6 +32,7 @@
 #ifndef SQLTransactionCoordinator_h
 #define SQLTransactionCoordinator_h
 
+#include "heap/Handle.h"
 #include "wtf/Deque.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
@@ -50,15 +51,23 @@ public:
     void releaseLock(SQLTransactionBackend*);
     void shutdown();
 private:
-    typedef Deque<RefPtr<SQLTransactionBackend> > TransactionsQueue;
+    typedef Deque<RefPtrWillBeMember<SQLTransactionBackend> > TransactionsQueue;
     struct CoordinationInfo {
         TransactionsQueue pendingTransactions;
-        HashSet<RefPtr<SQLTransactionBackend> > activeReadTransactions;
-        RefPtr<SQLTransactionBackend> activeWriteTransaction;
+        WillBeHeapHashSet<RefPtrWillBeMember<SQLTransactionBackend> > activeReadTransactions;
+        RefPtrWillBeMember<SQLTransactionBackend> activeWriteTransaction;
+
+        void trace(Visitor* visitor)
+        {
+            visitor->trace(pendingTransactions);
+            visitor->trace(activeReadTransactions);
+            visitor->trace(activeWriteTransaction);
+        }
+        ALLOW_ONLY_INLINE_ALLOCATION();
     };
     // Maps database names to information about pending transactions
-    typedef HashMap<String, CoordinationInfo> CoordinationInfoMap;
-    CoordinationInfoMap m_coordinationInfoMap;
+    typedef WillBePersistentHeapHashMap<String, CoordinationInfo> CoordinationInfoHeapMap;
+    CoordinationInfoHeapMap m_coordinationInfoMap;
     bool m_isShuttingDown;
 
     void processPendingTransactions(CoordinationInfo&);