Enable per thread heap for database thread

third_party/WebKit/Source/modules/webdatabase/SQLTransactionBackend.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 338 matching lines @@
     , m_wrapper(wrapper)
     , m_hasCallback(m_frontend->hasCallback())
     , m_hasSuccessCallback(m_frontend->hasSuccessCallback())
     , m_hasErrorCallback(m_frontend->hasErrorCallback())
     , m_shouldRetryCurrentStatement(false)
     , m_modifiedDatabase(false)
     , m_lockAcquired(false)
     , m_readOnly(readOnly)
     , m_hasVersionMismatch(false)
 {
+    DCHECK(isMainThread());
     ASSERT(m_database);
     m_frontend->setBackend(this);
     m_requestedState = SQLTransactionState::AcquireLock;
 }
 
 SQLTransactionBackend::~SQLTransactionBackend()
 {
     ASSERT(!m_sqliteTransaction);
 }
 
 DEFINE_TRACE(SQLTransactionBackend)
 {
-    visitor->trace(m_frontend);
-    visitor->trace(m_currentStatementBackend);
     visitor->trace(m_database);
     visitor->trace(m_wrapper);
-    visitor->trace(m_statementQueue);
 }
 
 void SQLTransactionBackend::doCleanup()
 {
     if (!m_frontend)
         return;
     m_frontend = nullptr; // Break the reference cycle. See comment about the life-cycle above.
 
     ASSERT(database()->getDatabaseContext()->databaseThread()->isDatabaseThread());
 
@@ skipping 74 matching lines @@
     };
 
     ASSERT(WTF_ARRAY_LENGTH(stateFunctions) == static_cast<int>(SQLTransactionState::NumberOfStates));
     ASSERT(state < SQLTransactionState::NumberOfStates);
 
     return stateFunctions[static_cast<int>(state)];
 }
 
 void SQLTransactionBackend::enqueueStatementBackend(SQLStatementBackend* statementBackend)
 {
+    DCHECK(isMainThread());
     MutexLocker locker(m_statementMutex);
     m_statementQueue.append(statementBackend);
 }
 
 void SQLTransactionBackend::computeNextStateAndCleanupIfNeeded()
 {
+    DCHECK(database()->getDatabaseContext()->databaseThread()->isDatabaseThread());
     // Only honor the requested state transition if we're not supposed to be
     // cleaning up and shutting down:
     if (m_database->opened()) {
         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);
@@ skipping 27 matching lines @@
 
 void SQLTransactionBackend::performNextStep()
 {
     computeNextStateAndCleanupIfNeeded();
     runStateMachine();
 }
 
 void SQLTransactionBackend::executeSQL(SQLStatement* statement,
     const String& sqlStatement, const Vector<SQLValue>& arguments, int permissions)
 {
+    DCHECK(isMainThread());
     enqueueStatementBackend(SQLStatementBackend::create(statement, sqlStatement, arguments, permissions));
 }
 
 void SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown()
 {
     ASSERT(database()->getDatabaseContext()->databaseThread()->isDatabaseThread());
 
     // 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.
     doCleanup();
 }
 
 SQLTransactionState SQLTransactionBackend::acquireLock()
 {
     m_database->transactionCoordinator()->acquireLock(this);
     return SQLTransactionState::Idle;
 }
 
 void SQLTransactionBackend::lockAcquired()
 {
     m_lockAcquired = true;
     requestTransitToState(SQLTransactionState::OpenTransactionAndPreflight);
 }
 
 SQLTransactionState SQLTransactionBackend::openTransactionAndPreflight()
 {
+    DCHECK(database()->getDatabaseContext()->databaseThread()->isDatabaseThread());
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
     ASSERT(m_lockAcquired);
 
     WTF_LOG(StorageAPI, "Opening and preflighting transaction %p", this);
 
     // Set the maximum usage for this transaction if this transactions is not read-only
     if (!m_readOnly)
         m_database->sqliteDatabase().setMaximumSize(m_database->maximumSize());
 
     ASSERT(!m_sqliteTransaction);
@@ skipping 46 matching lines @@
     // 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()
 {
+    DCHECK(database()->getDatabaseContext()->databaseThread()->isDatabaseThread());
     ASSERT(m_lockAcquired);
     SQLTransactionState nextState;
 
     // If there is a series of statements queued up that are all successful and have no associated
     // SQLStatementCallback objects, then we can burn through the queue
     do {
         if (m_shouldRetryCurrentStatement && !m_sqliteTransaction->wasRolledBackBySqlite()) {
             m_shouldRetryCurrentStatement = false;
             // FIXME - Another place that needs fixing up after <rdar://problem/5628468> is addressed.
             // See ::openTransactionAndPreflight() for discussion
@@ skipping 14 matching lines @@
             getNextStatement();
         }
         nextState = runCurrentStatementAndGetNextState();
     } while (nextState == SQLTransactionState::RunStatements);
 
     return nextState;
 }
 
 void SQLTransactionBackend::getNextStatement()
 {
+    DCHECK(database()->getDatabaseContext()->databaseThread()->isDatabaseThread());
     m_currentStatementBackend = nullptr;
 
     MutexLocker locker(m_statementMutex);
     if (!m_statementQueue.isEmpty())
         m_currentStatementBackend = m_statementQueue.takeFirst();
 }
 
 SQLTransactionState SQLTransactionBackend::runCurrentStatementAndGetNextState()
 {
     if (!m_currentStatementBackend) {
@@ skipping 156 matching lines @@
 }
 
 SQLTransactionState SQLTransactionBackend::sendToFrontendState()
 {
     ASSERT(m_nextState != SQLTransactionState::Idle);
     m_frontend->requestTransitToState(m_nextState);
     return SQLTransactionState::Idle;
 }
 
 } // namespace blink