Changeset 30104

Timestamp:

02/08/08 20:15:27 (10 months ago)

Author:

timothy@apple.com

Message:

Reviewed by Brady Eidson.

<rdar://problem/5640896> Removing database then trying
to recreate it causes trouble

Added open Database support to DatabaseTracker. So any Database that
is deleted will be marked as deleted and will fail to open any transaction
or execute any new SQL queries.

• storage/Database.cpp: (WebCore::Database::Database): Call DatabaseTracker::addOpenDatabase. (WebCore::Database::~Database): Call DatabaseTracker::removeOpenDatabase. (WebCore::Database::markAsDeleted): Set the m_deleted flag. (WebCore::Database::version): Return a null String if m_deleted is true.
• storage/Database.h: (WebCore::Database::deleted): Return m_deleted.
• storage/DatabaseTracker.cpp: (WebCore::DatabaseTracker::addOpenDatabase): Add the Database to a map of origins and names. (WebCore::DatabaseTracker::removeOpenDatabase): Remove the Database from the map. (WebCore::DatabaseTracker::deleteDatabaseFile): Call markAsDeleted on all the open Databases matching the origin/name.
• storage/DatabaseTracker.h:
• storage/SQLStatement.cpp: (WebCore::SQLStatement::setDatabaseDeletedError): Set the error about the user deleting the database.
• storage/SQLStatement.h:
• storage/SQLTransaction.cpp: (WebCore::SQLTransaction::executeSQL): If the Database is deleted, call setDatabaseDeletedError. (WebCore::SQLTransaction::openTransactionAndPreflight): Set the error about the user deleting the database if the Database was marked as deleted.

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• storage/Database.cpp (modified) (5 diffs)
• storage/Database.h (modified) (2 diffs)
• storage/DatabaseTracker.cpp (modified) (3 diffs)
• storage/DatabaseTracker.h (modified) (3 diffs)
• storage/SQLStatement.cpp (modified) (1 diff)
• storage/SQLStatement.h (modified) (1 diff)
• storage/SQLTransaction.cpp (modified) (2 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-02-08  Timothy Hatcher  <timothy@apple.com>
+
+        Reviewed by Brady Eidson.
+
+        <rdar://problem/5640896> Removing database then trying
+        to recreate it causes trouble
+
+        Added open Database support to DatabaseTracker. So any Database that 
+        is deleted will be marked as deleted and will fail to open any transaction
+        or execute any new SQL queries.
+
+        * storage/Database.cpp:
+        (WebCore::Database::Database): Call DatabaseTracker::addOpenDatabase.
+        (WebCore::Database::~Database): Call DatabaseTracker::removeOpenDatabase.
+        (WebCore::Database::markAsDeleted): Set the m_deleted flag.
+        (WebCore::Database::version): Return a null String if m_deleted is true.
+        * storage/Database.h:
+        (WebCore::Database::deleted): Return m_deleted.
+        * storage/DatabaseTracker.cpp:
+        (WebCore::DatabaseTracker::addOpenDatabase): Add the Database to a map of origins and names.
+        (WebCore::DatabaseTracker::removeOpenDatabase): Remove the Database from the map.
+        (WebCore::DatabaseTracker::deleteDatabaseFile): Call markAsDeleted on all the open Databases
+          matching the origin/name.
+        * storage/DatabaseTracker.h:
+        * storage/SQLStatement.cpp:
+        (WebCore::SQLStatement::setDatabaseDeletedError): Set the error about the user deleting the database.
+        * storage/SQLStatement.h:
+        * storage/SQLTransaction.cpp:
+        (WebCore::SQLTransaction::executeSQL): If the Database is deleted, call setDatabaseDeletedError.
+        (WebCore::SQLTransaction::openTransactionAndPreflight): Set the error about the user deleting the database
+          if the Database was marked as deleted.
+
 2008-02-08  Darin Adler  <darin@apple.com>
 

trunk/WebCore/storage/Database.cpp

@@ -146 +146 @@
     , m_guid(0)
     , m_expectedVersion(expectedVersion)
+    , m_deleted(0)
     , m_databaseThread(0)
 #ifndef NDEBUG
@@ -177 +178 @@
 
     m_filename = DatabaseTracker::tracker().fullPathForDatabase(m_securityOrigin.get(), m_name);
+
+    DatabaseTracker::tracker().addOpenDatabase(this);
 }
 
@@ -192 +195 @@
         guidToVersionMap().remove(m_guid);
     }
+
+    DatabaseTracker::tracker().removeOpenDatabase(this);
 }
 
@@ -292 +297 @@
     
     return true;
+}
+
+void Database::markAsDeleted()
+{
+    if (m_deleted)
+        return;
+    LOG(StorageAPI, "Marking %s (%p) as deleted", stringIdentifier().ascii().data(), this);
+    m_deleted = true;
 }
 
@@ -557 +570 @@
 String Database::version() const
 {
+    if (m_deleted)
+        return String();
     MutexLocker locker(guidMutex());
     return guidToVersionMap().get(m_guid).copy();

trunk/WebCore/storage/Database.h

@@ -90 +90 @@
     void setExpectedVersion(const String&);
     bool versionMatchesExpected() const;
-    
+
+    void markAsDeleted();
+    bool deleted() const { return m_deleted; }
+
     unsigned long long databaseSize() const;
     unsigned long long maximumSize() const;
@@ -127 +130 @@
     String m_filename;
 
+    bool m_deleted;
+
     SQLiteDatabase m_sqliteDatabase;
     RefPtr<DatabaseAuthorizer> m_databaseAuthorizer;

trunk/WebCore/storage/DatabaseTracker.cpp

@@ -35 +35 @@
 #include "Document.h"
 #include "FileSystem.h"
+#include "Logging.h"
 #include "OriginQuotaManager.h"
 #include "Page.h"
@@ -421 +422 @@
 }
 
+void DatabaseTracker::addOpenDatabase(Database* database)
+{
+    if (!database)
+        return;
+
+    MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+
+    if (!m_openDatabaseMap)
+        m_openDatabaseMap.set(new DatabaseOriginMap);
+
+    RefPtr<SecurityOrigin> origin(database->securityOriginCopy());
+    String name(database->stringIdentifier());
+
+    DatabaseNameMap* nameMap = m_openDatabaseMap->get(origin);
+    if (!nameMap) {
+        nameMap = new DatabaseNameMap;
+        m_openDatabaseMap->set(origin, nameMap);
+    }
+
+    DatabaseSet* databaseSet = nameMap->get(name);
+    if (!databaseSet) {
+        databaseSet = new DatabaseSet;
+        nameMap->set(name, databaseSet);
+    }
+
+    databaseSet->add(database);
+
+    LOG(StorageAPI, "Added open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);
+}
+
+void DatabaseTracker::removeOpenDatabase(Database* database)
+{
+    if (!database)
+        return;
+
+    MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+
+    if (!m_openDatabaseMap) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    RefPtr<SecurityOrigin> origin(database->securityOriginCopy());
+    String name(database->stringIdentifier());
+
+    DatabaseNameMap* nameMap = m_openDatabaseMap->get(origin);
+    if (!nameMap) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    DatabaseSet* databaseSet = nameMap->get(name);
+    if (!databaseSet) {
+        ASSERT_NOT_REACHED();
+        return;
+    }
+
+    databaseSet->remove(database);
+
+    LOG(StorageAPI, "Removed open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);
+
+    if (!databaseSet->isEmpty())
+        return;
+
+    nameMap->remove(name);
+    delete databaseSet;
+
+    if (!nameMap->isEmpty())
+        return;
+
+    m_openDatabaseMap->remove(origin);
+    delete nameMap;
+}
+
 unsigned long long DatabaseTracker::usageForOrigin(SecurityOrigin* origin)
 {
@@ -650 +725 @@
     if (fullPath.isEmpty())
         return true;
-        
+
+    {
+        MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
+        if (m_openDatabaseMap) {
+            // There are some open databases, lets check if they are for this origin.
+            DatabaseNameMap* nameMap = m_openDatabaseMap->get(origin);
+            if (nameMap && nameMap->size()) {
+                // There are some open databases for this origin, lets check
+                // if they are this database by name.
+                DatabaseSet* databaseSet = nameMap->get(name);
+                if (databaseSet && databaseSet->size()) {
+                    // We have some database open with this name. Mark them as deleted.
+                    DatabaseSet::const_iterator end = databaseSet->end();
+                    for (DatabaseSet::const_iterator it = databaseSet->begin(); it != end; ++it)
+                        (*it)->markAsDeleted();
+                }
+            }
+        }
+    }
+
     return deleteFile(fullPath);
 }

trunk/WebCore/storage/DatabaseTracker.h

@@ -39 +39 @@
 namespace WebCore {
 
+class Database;
 class DatabaseTrackerClient;
 class Document;
@@ -60 +61 @@
 
     DatabaseDetails detailsForNameAndOrigin(const String&, SecurityOrigin*);
-    
+
+    void addOpenDatabase(Database*);
+    void removeOpenDatabase(Database*);
+
     unsigned long long usageForDatabase(const String&, SecurityOrigin*);
     unsigned long long usageForOrigin(SecurityOrigin*);
@@ -100 +104 @@
     Mutex m_quotaMapGuard;
     mutable OwnPtr<QuotaMap> m_quotaMap;
-    
+
+    typedef HashSet<Database*> DatabaseSet;
+    typedef HashMap<String, DatabaseSet*> DatabaseNameMap;
+    typedef HashMap<RefPtr<SecurityOrigin>, DatabaseNameMap*, SecurityOriginHash, SecurityOriginTraits> DatabaseOriginMap;
+
+    Mutex m_openDatabaseMapGuard;
+    mutable OwnPtr<DatabaseOriginMap> m_openDatabaseMap;
+
     OwnPtr<OriginQuotaManager> m_quotaManager;
 

trunk/WebCore/storage/SQLStatement.cpp

@@ -140 +140 @@
 }
 
+void SQLStatement::setDatabaseDeletedError()
+{
+    ASSERT(!m_error && !m_resultSet);
+    m_error = new SQLError(0, "unable to execute statement, because the user deleted the database");
+}
+
 void SQLStatement::setVersionMismatchedError()
 {

trunk/WebCore/storage/SQLStatement.h

@@ -57 +57 @@
     bool hasStatementCallback() const { return m_statementCallback; }
     bool hasStatementErrorCallback() const { return m_statementErrorCallback; }
+
+    void setDatabaseDeletedError();
     void setVersionMismatchedError();
 

trunk/WebCore/storage/SQLTransaction.cpp

@@ -79 +79 @@
     
     RefPtr<SQLStatement> statement = new SQLStatement(sqlStatement.copy(), arguments, callback, callbackError);
-    
+
+    if (m_database->deleted())
+        statement->setDatabaseDeletedError();
+
     if (!m_database->versionMatchesExpected())
         statement->setVersionMismatchedError();
@@ -120 +123 @@
 
     LOG(StorageAPI, "Opening and preflighting transaction %p", this);
-    
+
+    // If the database was deleted, jump to the error callback
+    if (m_database->deleted()) {
+        m_transactionError = new SQLError(0, "unable to open a transaction, because the user deleted the database");
+        handleTransactionError(false);
+        return;
+    }
+
     // Set the maximum usage for this transaction
     m_database->m_sqliteDatabase.setMaximumSize(m_database->maximumSize());