Rollback transactions by observing them weakly from DatabaseSync.

Source/modules/webdatabase/DatabaseSync.cpp

 /*
  * Copyright (C) 2010 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 66 matching lines @@
 {
     ASSERT(executionContext()->isContextThread());
 
     if (sqliteDatabase().transactionInProgress()) {
         reportChangeVersionResult(1, SQLError::DATABASE_ERR, 0);
         setLastErrorMessage("unable to changeVersion from within a transaction");
         exceptionState.throwDOMException(SQLDatabaseError, "Unable to change version from within a transaction.");
         return;
     }
 
-    RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
+    RefPtrWillBeRawPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, changeVersionCallback, false);
     transaction->begin(exceptionState);
     if (exceptionState.hadException()) {
         ASSERT(!lastErrorMessage().isEmpty());
         return;
     }
 
     String actualVersion;
     if (!getVersionFromDatabase(actualVersion)) {
         reportChangeVersionResult(2, SQLError::UNKNOWN_ERR, sqliteDatabase().lastError());
         setLastErrorMessage("unable to read the current version", sqliteDatabase().lastError(), sqliteDatabase().lastErrorMsg());
@@ skipping 38 matching lines @@
 void DatabaseSync::transaction(PassOwnPtr<SQLTransactionSyncCallback> callback, ExceptionState& exceptionState)
 {
     runTransaction(callback, false, exceptionState);
 }
 
 void DatabaseSync::readTransaction(PassOwnPtr<SQLTransactionSyncCallback> callback, ExceptionState& exceptionState)
 {
     runTransaction(callback, true, exceptionState);
 }
 
-void DatabaseSync::rollbackTransaction(PassRefPtr<SQLTransactionSync> transaction)
+void DatabaseSync::rollbackTransaction(SQLTransactionSync& transaction)
 {
     ASSERT(!lastErrorMessage().isEmpty());
-    transaction->rollback();
+    transaction.rollback();
     setLastErrorMessage("");
     return;
 }
 
 void DatabaseSync::runTransaction(PassOwnPtr<SQLTransactionSyncCallback> callback, bool readOnly, ExceptionState& exceptionState)
 {
     ASSERT(executionContext()->isContextThread());
 
     if (sqliteDatabase().transactionInProgress()) {
         setLastErrorMessage("unable to start a transaction from within a transaction");
         exceptionState.throwDOMException(SQLDatabaseError, "Unable to start a transaction from within a transaction.");
         return;
     }
 
-    RefPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
+    RefPtrWillBeRawPtr<SQLTransactionSync> transaction = SQLTransactionSync::create(this, callback, readOnly);
     transaction->begin(exceptionState);
     if (exceptionState.hadException()) {
-        rollbackTransaction(transaction);
+        rollbackTransaction(*transaction);
         return;
     }
 
     transaction->execute(exceptionState);
     if (exceptionState.hadException()) {
-        rollbackTransaction(transaction);
+        rollbackTransaction(*transaction);
         return;
     }
 
     transaction->commit(exceptionState);
     if (exceptionState.hadException()) {
-        rollbackTransaction(transaction);
+        rollbackTransaction(*transaction);
         return;
     }
 
     setLastErrorMessage("");
 }
 
 void DatabaseSync::closeImmediately()
 {
     ASSERT(executionContext()->isContextThread());
 
     if (!opened())
         return;
 
     logErrorMessage("forcibly closing database");
     closeDatabase();
 }
 
+#if ENABLE(OILPAN)
+void DatabaseSync::registerTransaction(SQLTransactionSync* sync)
+{
+    ObserverMap::AddResult result = m_observers.add(sync, nullptr);
+    ASSERT(result.isNewEntry);
+    result.storedValue->value = adoptPtr(new TransactionObserver(sync));
+}
+
+DatabaseSync::TransactionObserver::~TransactionObserver()
+{
+    m_sync->rollbackIfInProgress();
+}
+#endif
+
 } // namespace WebCore