Oilpan: Prepare to move SQLError to oilpan heap.

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 415 matching lines @@
     // is also destructing.
 
     m_wrapper = nullptr;
 }
 
 AbstractSQLStatement* SQLTransactionBackend::currentStatement()
 {
     return m_currentStatementBackend->frontend();
 }
 
-PassRefPtr<SQLError> SQLTransactionBackend::transactionError()
+SQLErrorData* SQLTransactionBackend::transactionError()
 {
-    return m_transactionError;
+    return m_transactionError.get();
 }
 
 void SQLTransactionBackend::setShouldRetryCurrentStatement(bool shouldRetry)
 {
     ASSERT(!m_shouldRetryCurrentStatement);
     m_shouldRetryCurrentStatement = shouldRetry;
 }
 
 SQLTransactionBackend::StateFunction SQLTransactionBackend::stateFunctionFor(SQLTransactionState state)
 {
@@ skipping 117 matching lines @@
 
     m_database->resetDeletes();
     m_database->disableAuthorizer();
     m_sqliteTransaction->begin();
     m_database->enableAuthorizer();
 
     // Spec 4.3.2.1+2: Open a transaction to the database, jumping to the error callback if that fails
     if (!m_sqliteTransaction->inProgress()) {
         ASSERT(!m_database->sqliteDatabase().transactionInProgress());
         m_database->reportStartTransactionResult(2, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
-        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to begin transaction",
+        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "unable to begin transaction",
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         m_sqliteTransaction.clear();
         return nextStateForTransactionError();
     }
 
     // Note: We intentionally retrieve the actual version even with an empty expected version.
     // In multi-process browsers, we take this opportinutiy to update the cached value for
     // the actual version. In single-process browsers, this is just a map lookup.
     String actualVersion;
     if (!m_database->getActualVersionForTransaction(actualVersion)) {
         m_database->reportStartTransactionResult(3, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
-        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to read version",
+        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "unable to read version",
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         m_database->disableAuthorizer();
         m_sqliteTransaction.clear();
         m_database->enableAuthorizer();
         return nextStateForTransactionError();
     }
     m_hasVersionMismatch = !m_database->expectedVersion().isEmpty() && (m_database->expectedVersion() != actualVersion);
 
     // Spec 4.3.2.3: Perform preflight steps, jumping to the error callback if they fail
     if (m_wrapper && !m_wrapper->performPreflight(this)) {
         m_database->disableAuthorizer();
         m_sqliteTransaction.clear();
         m_database->enableAuthorizer();
-        m_transactionError = m_wrapper->sqlError();
-        if (!m_transactionError) {
+        if (m_wrapper->sqlError()) {
+            m_transactionError = SQLErrorData::create(*m_wrapper->sqlError());
+        } else {
             m_database->reportStartTransactionResult(4, SQLError::UNKNOWN_ERR, 0);
-            m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction preflight");
+            m_transactionError = SQLErrorData::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction preflight");
         }
         return nextStateForTransactionError();
     }
 
     // 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;
@@ skipping 76 matching lines @@
     return nextStateForCurrentStatementError();
 }
 
 SQLTransactionState SQLTransactionBackend::nextStateForCurrentStatementError()
 {
     // Spec 4.3.2.6.6: error - Call the statement's error callback, but if there was no error callback,
     // or the transaction was rolled back, jump to the transaction error callback
     if (m_currentStatementBackend->hasStatementErrorCallback() && !m_sqliteTransaction->wasRolledBackBySqlite())
         return SQLTransactionState::DeliverStatementCallback;
 
-    m_transactionError = m_currentStatementBackend->sqlError();
-    if (!m_transactionError) {
+    if (m_currentStatementBackend->sqlError()) {
+        m_transactionError = SQLErrorData::create(*m_currentStatementBackend->sqlError());
+    } else {
         m_database->reportCommitTransactionResult(1, SQLError::DATABASE_ERR, 0);
-        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "the statement failed to execute");
+        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "the statement failed to execute");
     }
     return nextStateForTransactionError();
 }
 
 SQLTransactionState SQLTransactionBackend::postflightAndCommit()
 {
     ASSERT(m_lockAcquired);
 
     // Spec 4.3.2.7: Perform postflight steps, jumping to the error callback if they fail.
     if (m_wrapper && !m_wrapper->performPostflight(this)) {
-        m_transactionError = m_wrapper->sqlError();
-        if (!m_transactionError) {
+        if (m_wrapper->sqlError()) {
+            m_transactionError = SQLErrorData::create(*m_wrapper->sqlError());
+        } else {
             m_database->reportCommitTransactionResult(3, SQLError::UNKNOWN_ERR, 0);
-            m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction postflight");
+            m_transactionError = SQLErrorData::create(SQLError::UNKNOWN_ERR, "unknown error occurred during transaction postflight");
         }
         return nextStateForTransactionError();
     }
 
     // Spec 4.3.2.7: Commit the transaction, jumping to the error callback if that fails.
     ASSERT(m_sqliteTransaction);
 
     m_database->disableAuthorizer();
     m_sqliteTransaction->commit();
     m_database->enableAuthorizer();
 
     // If the commit failed, the transaction will still be marked as "in progress"
     if (m_sqliteTransaction->inProgress()) {
         if (m_wrapper)
             m_wrapper->handleCommitFailedAfterPostflight(this);
         m_database->reportCommitTransactionResult(4, SQLError::DATABASE_ERR, m_database->sqliteDatabase().lastError());
-        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to commit transaction",
+        m_transactionError = SQLErrorData::create(SQLError::DATABASE_ERR, "unable to commit transaction",
             m_database->sqliteDatabase().lastError(), m_database->sqliteDatabase().lastErrorMsg());
         return nextStateForTransactionError();
     }
 
     m_database->reportCommitTransactionResult(0, -1, 0); // OK
 
     // Vacuum the database if anything was deleted.
     if (m_database->hadDeletes())
         m_database->incrementalVacuumIfNeeded();
 
@@ skipping 71 matching lines @@
 }
 
 SQLTransactionState SQLTransactionBackend::sendToFrontendState()
 {
     ASSERT(m_nextState != SQLTransactionState::Idle);
     m_frontend->requestTransitToState(m_nextState);
     return SQLTransactionState::Idle;
 }
 
 } // namespace WebCore