Merge 92155 - [Chromium] WebSQLDatabase version handling is broken in multi-process browsers.

Source/WebCore/storage/SQLTransaction.cpp

 /*
  * Copyright (C) 2007, 2008 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 60 matching lines @@
     , m_executeSqlAllowed(false)
     , m_database(db)
     , m_wrapper(wrapper)
     , m_callbackWrapper(callback, db->scriptExecutionContext())
     , m_successCallbackWrapper(successCallback, db->scriptExecutionContext())
     , m_errorCallbackWrapper(errorCallback, db->scriptExecutionContext())
     , m_shouldRetryCurrentStatement(false)
     , m_modifiedDatabase(false)
     , m_lockAcquired(false)
     , m_readOnly(readOnly)
+    , m_hasVersionMismatch(false)
 {
     ASSERT(m_database);
 }
 
 SQLTransaction::~SQLTransaction()
 {
     ASSERT(!m_sqliteTransaction);
 }
 
 void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassRefPtr<SQLStatementCallback> callback, PassRefPtr<SQLStatementErrorCallback> callbackError, ExceptionCode& e)
 {
     if (!m_executeSqlAllowed || !m_database->opened()) {
         e = INVALID_STATE_ERR;
         return;
     }
 
     int permissions = DatabaseAuthorizer::ReadWriteMask;
     if (!m_database->scriptExecutionContext()->allowDatabaseAccess())
         permissions |= DatabaseAuthorizer::NoAccessMask;
     else if (m_readOnly)
         permissions |= DatabaseAuthorizer::ReadOnlyMask;
 
     RefPtr<SQLStatement> statement = SQLStatement::create(m_database.get(), sqlStatement, arguments, callback, callbackError, permissions);
 
     if (m_database->deleted())
         statement->setDatabaseDeletedError();
 
-    if (!m_database->versionMatchesExpected())
-        statement->setVersionMismatchedError();
-
     enqueueStatement(statement);
 }
 
 void SQLTransaction::enqueueStatement(PassRefPtr<SQLStatement> statement)
 {
     MutexLocker locker(m_statementMutex);
     m_statementQueue.append(statement);
 }
 
 #if !LOG_DISABLED
@@ skipping 144 matching lines @@
 
     // Transaction Steps 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_sqliteTransaction.clear();
         m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to open a transaction to the database");
         handleTransactionError(false);
         return;
     }
 
+    // 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->disableAuthorizer();
+        m_sqliteTransaction.clear();
+        m_database->enableAuthorizer();
+        m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "unable to read version");
+        handleTransactionError(false);
+        return;
+    }
+    m_hasVersionMismatch = !m_database->expectedVersion().isEmpty()
+                           && (m_database->expectedVersion() != actualVersion);
+
     // Transaction Steps 3 - Peform 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)
             m_transactionError = SQLError::create(SQLError::UNKNOWN_ERR, "unknown error occured setting up transaction");
 
         handleTransactionError(false);
         return;
     }
 
     // Transaction Step 4 - Invoke the transaction callback with the new SQLTransaction object
     m_nextStep = &SQLTransaction::deliverTransactionCallback;
@@ skipping 74 matching lines @@
     }
 }
 
 bool SQLTransaction::runCurrentStatement()
 {
     if (!m_currentStatement)
         return false;
 
     m_database->resetAuthorizer();
 
+    if (m_hasVersionMismatch)
+        m_currentStatement->setVersionMismatchedError();
+
     if (m_currentStatement->execute(m_database.get())) {
         if (m_database->lastActionChangedDatabase()) {
             // Flag this transaction as having changed the database for later delegate notification
             m_modifiedDatabase = true;
             // Also dirty the size of this database file for calculating quota usage
             m_database->transactionClient()->didExecuteStatement(database());
         }
 
         if (m_currentStatement->hasStatementCallback()) {
             m_nextStep = &SQLTransaction::deliverStatementCallback;
@@ skipping 76 matching lines @@
 
     // Transacton Step 8+9 - 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_successCallbackWrapper.clear();
         m_transactionError = SQLError::create(SQLError::DATABASE_ERR, "failed to commit the transaction");
         handleTransactionError(false);
         return;
     }
 
     // Vacuum the database if anything was deleted.
     if (m_database->hadDeletes())
         m_database->incrementalVacuumIfNeeded();
 
@@ skipping 106 matching lines @@
     ASSERT(!m_database->sqliteDatabase().transactionInProgress());
     m_nextStep = 0;
 
     // Now release the lock on this database
     m_database->transactionCoordinator()->releaseLock(this);
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(DATABASE)