Changeset 30184 in webkit

Timestamp:

Feb 12, 2008 5:10:42 PM (16 years ago)

Author:

beidson@apple.com

Message:

Reviewed by Darin Adler

Fix for <rdar://problem/5737692> - Database API needs to support SuccessCallback

Layout tests will come shortly with a mess of DRT changes

• platform/SecurityOrigin.cpp: (WebCore::SecurityOrigin::SecurityOrigin): Standardize on "empty string" instead of null string as different paths of constructing a SecurityOrigin were causing different hashes for the "same" SecurityOrigin

• storage/Database.cpp: (WebCore::Database::changeVersion): Pass in the successCallback (WebCore::Database::transaction): Ditto

• storage/SQLTransaction.cpp: (WebCore::SQLTransaction::SQLTransaction): (WebCore::SQLTransaction::debugStepName): (WebCore::SQLTransaction::performNextStep): Update ASSERTs for the new valid steps (WebCore::SQLTransaction::performPendingCallback): Ditto (WebCore::SQLTransaction::postflightAndCommit): Schedule the success callback if it exists - otherwise skip straight to cleanupAfterSuccessCallback() (WebCore::SQLTransaction::deliverSuccessCallback): Deliver success callback on the main thread, then schedule cleanupAfterSuccessCallback() (WebCore::SQLTransaction::cleanupAfterSuccessCallback): Cleanup and end the transaction (WebCore::SQLTransaction::handleTransactionError): (WebCore::SQLTransaction::deliverTransactionErrorCallback): (WebCore::SQLTransaction::cleanupAfterTransactionErrorCallback):
• storage/SQLTransaction.h:

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/SecurityOrigin.cpp (modified) (2 diffs)
• storage/Database.cpp (modified) (2 diffs)
• storage/SQLTransaction.cpp (modified) (11 diffs)
• storage/SQLTransaction.h (modified) (4 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-02-12  Brady Eidson  <beidson@apple.com>
+
+        Reviewed by Darin Adler
+
+        Fix for <rdar://problem/5737692> - Database API needs to support SuccessCallback
+
+        Layout tests will come shortly with a mess of DRT changes
+
+        * platform/SecurityOrigin.cpp:
+        (WebCore::SecurityOrigin::SecurityOrigin): Standardize on "empty string" instead of null string
+          as different paths of constructing a SecurityOrigin were causing different hashes for the "same"
+          SecurityOrigin
+
+        * storage/Database.cpp:
+        (WebCore::Database::changeVersion): Pass in the successCallback
+        (WebCore::Database::transaction): Ditto
+
+        * storage/SQLTransaction.cpp:
+        (WebCore::SQLTransaction::SQLTransaction):
+        (WebCore::SQLTransaction::debugStepName):
+        (WebCore::SQLTransaction::performNextStep): Update ASSERTs for the new valid steps
+        (WebCore::SQLTransaction::performPendingCallback): Ditto
+        (WebCore::SQLTransaction::postflightAndCommit): Schedule the success callback if it exists - otherwise
+          skip straight to cleanupAfterSuccessCallback()
+        (WebCore::SQLTransaction::deliverSuccessCallback): Deliver success callback on the main thread, then
+          schedule cleanupAfterSuccessCallback()
+        (WebCore::SQLTransaction::cleanupAfterSuccessCallback): Cleanup and end the transaction
+        (WebCore::SQLTransaction::handleTransactionError):
+        (WebCore::SQLTransaction::deliverTransactionErrorCallback):
+        (WebCore::SQLTransaction::cleanupAfterTransactionErrorCallback):
+        * storage/SQLTransaction.h:
+
 2008-02-12  Steve Falkenburg  <sfalken@apple.com>
 

trunk/WebCore/platform/SecurityOrigin.cpp

@@ -55 +55 @@
 
 SecurityOrigin::SecurityOrigin(const String& protocol, const String& host, unsigned short port)
-    : m_protocol(protocol.lower())
-    , m_host(host.lower())
+    : m_protocol(protocol.isNull() ? "" : protocol.lower())
+    , m_host(host.isNull() ? "" : host.lower())
     , m_port(port)
     , m_portSet(port)
@@ -64 +64 @@
     // These protocols do not create security origins; the owner frame provides the origin
     if (m_protocol == "about" || m_protocol == "javascript")
-        m_protocol = String();
+        m_protocol = "";
 
     // data: URLs are not allowed access to anything other than themselves.

trunk/WebCore/storage/Database.cpp

@@ -425 +425 @@
                              PassRefPtr<VoidCallback> successCallback)
 {
-    // FIXME: pass successCallback, too.
-    m_transactionQueue.append(new SQLTransaction(this, callback, errorCallback, new ChangeVersionWrapper(oldVersion, newVersion)));
+    m_transactionQueue.append(new SQLTransaction(this, callback, errorCallback, successCallback, new ChangeVersionWrapper(oldVersion, newVersion)));
     MutexLocker locker(m_transactionInProgressMutex);
     if (!m_transactionInProgress)
@@ -435 +434 @@
                            PassRefPtr<VoidCallback> successCallback)
 {
-    // FIXME: pass successCallback, too.
-    m_transactionQueue.append(new SQLTransaction(this, callback, errorCallback, 0));
+    m_transactionQueue.append(new SQLTransaction(this, callback, errorCallback, successCallback, 0));
     MutexLocker locker(m_transactionInProgressMutex);
     if (!m_transactionInProgress)

trunk/WebCore/storage/SQLTransaction.cpp

@@ -57 +57 @@
 namespace WebCore {
 
-SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<SQLTransactionWrapper> wrapper)
+SQLTransaction::SQLTransaction(Database* db, PassRefPtr<SQLTransactionCallback> callback, PassRefPtr<SQLTransactionErrorCallback> errorCallback, PassRefPtr<VoidCallback> successCallback, 
+                               PassRefPtr<SQLTransactionWrapper> wrapper)
     : m_nextStep(&SQLTransaction::openTransactionAndPreflight)
     , m_executeSqlAllowed(false)
@@ -63 +64 @@
     , m_wrapper(wrapper)
     , m_callback(callback)
+    , m_successCallback(successCallback)
     , m_errorCallback(errorCallback)
     , m_shouldRetryCurrentStatement(false)
@@ -119 +121 @@
     else if (step == &SQLTransaction::deliverQuotaIncreaseCallback)
         return "deliverQuotaIncreaseCallback";
+    else if (step == &SQLTransaction::deliverSuccessCallback)
+        return "deliverSuccessCallback";
+    else if (step == &SQLTransaction::cleanupAfterSuccessCallback)
+        return "cleanupAfterSuccessCallback";
     else
         return "UNKNOWN";
@@ -131 +137 @@
            m_nextStep == &SQLTransaction::runStatements ||
            m_nextStep == &SQLTransaction::postflightAndCommit ||
+           m_nextStep == &SQLTransaction::cleanupAfterSuccessCallback ||
            m_nextStep == &SQLTransaction::cleanupAfterTransactionErrorCallback);
                
@@ -146 +153 @@
            m_nextStep == &SQLTransaction::deliverTransactionErrorCallback ||
            m_nextStep == &SQLTransaction::deliverStatementCallback ||
-           m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback);
+           m_nextStep == &SQLTransaction::deliverQuotaIncreaseCallback ||
+           m_nextStep == &SQLTransaction::deliverSuccessCallback);
            
     (this->*m_nextStep)();
@@ -395 +403 @@
         DatabaseTracker::tracker().scheduleNotifyDatabaseChanged(m_database->m_securityOrigin.get(), m_database->m_name);
     
-    // Transaction Step 10 - End transaction steps
+    // Now release our unneeded callbacks, to break reference cycles.
+    m_callback = 0;
+    m_errorCallback = 0;
+    
+    // Transaction Step 10 - Deliver success callback, if there is one
+    if (m_successCallback) {
+        m_nextStep = &SQLTransaction::deliverSuccessCallback;
+        LOG(StorageAPI, "Scheduling deliverSuccessCallback for transaction %p\n", this);
+        m_database->scheduleTransactionCallback(this);
+    } else 
+        cleanupAfterSuccessCallback();
+}
+
+void SQLTransaction::deliverSuccessCallback()
+{
+    // Transaction Step 10 - Deliver success callback
+    ASSERT(m_successCallback);
+    m_successCallback->handleEvent();
+    
+    // Release the last callback to break reference cycle
+    m_successCallback = 0;
+
+    // Schedule a "post-success callback" step to return control to the database thread in case there
+    // are further transactions queued up for this Database
+    m_nextStep = &SQLTransaction::cleanupAfterSuccessCallback;
+    LOG(StorageAPI, "Scheduling cleanupAfterSuccessCallback for transaction %p\n", this);
+    m_database->scheduleTransactionStep(this);
+}
+
+void SQLTransaction::cleanupAfterSuccessCallback()
+{
+    // Transaction Step 11 - End transaction steps
     // There is no next step
     LOG(StorageAPI, "Transaction %p is complete\n", this);
     ASSERT(!m_database->m_sqliteDatabase.transactionInProgress());
     m_nextStep = 0;
-
-    // Now release our callbacks, to break reference cycles.
-    m_callback = 0;
-    m_errorCallback = 0;
 }
 
@@ -419 +454 @@
     }
     
-    // Transaction Step 11 - If the callback couldn't be called, then rollback the transaction.
+    // Transaction Step 12 - If the callback couldn't be called, then rollback the transaction.
     m_shouldCommitAfterErrorCallback = false;
     if (inCallback) {
@@ -434 +469 @@
     ASSERT(m_transactionError);
     
-    // Transaction Step 11 - If the callback didn't return false, then rollback the transaction.
+    // Transaction Step 12 - If the callback didn't return false, then rollback the transaction.
     // This includes the callback not existing, returning true, or throwing an exception
     if (!m_errorCallback || m_errorCallback->handleEvent(m_transactionError.get()))
@@ -448 +483 @@
     m_database->m_databaseAuthorizer->disable();
     if (m_sqliteTransaction) {
-        // Transaction Step 11 -If the error callback returned false, and the last error wasn't itself a 
+        // Transaction Step 12 -If the error callback returned false, and the last error wasn't itself a 
         // failure when committing the transaction, then try to commit the transaction
         if (m_shouldCommitAfterErrorCallback)
@@ -454 +489 @@
         
         if (m_sqliteTransaction->inProgress()) {
-            // Transaction Step 11 - If that fails, or if the callback couldn't be called 
+            // Transaction Step 12 - If that fails, or if the callback couldn't be called 
             // or if it didn't return false, then rollback the transaction.
             m_sqliteTransaction->rollback();
@@ -467 +502 @@
     m_database->m_databaseAuthorizer->enable();
     
-    // Transaction Step 11 - Any still-pending statements in the transaction are discarded.
+    // Transaction Step 12 - Any still-pending statements in the transaction are discarded.
     {
         MutexLocker locker(m_statementMutex);

trunk/WebCore/storage/SQLTransaction.h

@@ -52 +52 @@
 class SQLValue;
 class String;
+class VoidCallback;
 
 class SQLTransactionWrapper : public ThreadSafeShared<SQLTransactionWrapper> {
@@ -64 +65 @@
 class SQLTransaction : public ThreadSafeShared<SQLTransaction> {
 public:
-    SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>, PassRefPtr<SQLTransactionWrapper>);
+    SQLTransaction(Database*, PassRefPtr<SQLTransactionCallback>, PassRefPtr<SQLTransactionErrorCallback>, PassRefPtr<VoidCallback>, PassRefPtr<SQLTransactionWrapper>);
     ~SQLTransaction();
     
@@ -91 +92 @@
     void deliverQuotaIncreaseCallback();
     void postflightAndCommit();
+    void deliverSuccessCallback();
+    void cleanupAfterSuccessCallback();
     void handleTransactionError(bool inCallback);
     void deliverTransactionErrorCallback();
@@ -106 +109 @@
     RefPtr<SQLTransactionWrapper> m_wrapper;
     RefPtr<SQLTransactionCallback> m_callback;
+    RefPtr<VoidCallback> m_successCallback;
     RefPtr<SQLTransactionErrorCallback> m_errorCallback;
     RefPtr<SQLError> m_transactionError;