Make the DatabaseTracker thread-safe.

WebCore/storage/Database.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 334 matching lines @@
         return;
     }
 
     m_scriptExecutionContext->databaseThread()->unscheduleDatabaseTasks(this);
 
     DatabaseTaskSynchronizer synchronizer;
     OwnPtr<DatabaseCloseTask> task = DatabaseCloseTask::create(this, &synchronizer);
 
     m_scriptExecutionContext->databaseThread()->scheduleImmediateTask(task.release());
     synchronizer.waitForTaskCompletion();
+
+    // DatabaseCloseTask tells Database::close not to do this, so that we can get it over with here.
+    m_scriptExecutionContext->removeOpenDatabase(this);
+    DatabaseTracker::tracker().removeOpenDatabase(this);
 }
 
 class ContextRemoveOpenDatabaseTask : public ScriptExecutionContext::Task {
 public:
     static PassOwnPtr<ContextRemoveOpenDatabaseTask> create(PassRefPtr<Database> database)
     {
         return new ContextRemoveOpenDatabaseTask(database);
     }
 
     virtual void performTask(ScriptExecutionContext* context)
     {
         context->removeOpenDatabase(m_database.get());
         DatabaseTracker::tracker().removeOpenDatabase(m_database.get());
     }
 
     virtual bool isCleanupTask() const { return true; }
 
 private:
     ContextRemoveOpenDatabaseTask(PassRefPtr<Database> database)
         : m_database(database)
     {
     }
 
     RefPtr<Database> m_database;
 };
 
-void Database::close()
+void Database::close(bool removeDatabaseFromContext)
 {
     RefPtr<Database> protect = this;
 
     if (!m_opened)
         return;
 
     ASSERT(m_scriptExecutionContext->databaseThread());
     ASSERT(currentThread() == m_scriptExecutionContext->databaseThread()->getThreadID());
     m_sqliteDatabase.close();
     // Must ref() before calling databaseThread()->recordDatabaseClosed().
     m_scriptExecutionContext->databaseThread()->recordDatabaseClosed(this);
     m_opened = false;
 
     {
         MutexLocker locker(guidMutex());
 
         HashSet<Database*>* hashSet = guidToDatabaseMap().get(m_guid);
         ASSERT(hashSet);
         ASSERT(hashSet->contains(this));
         hashSet->remove(this);
         if (hashSet->isEmpty()) {
             guidToDatabaseMap().remove(m_guid);
             delete hashSet;
             guidToVersionMap().remove(m_guid);
         }
     }
 
     m_scriptExecutionContext->databaseThread()->unscheduleDatabaseTasks(this);
-    m_scriptExecutionContext->postTask(ContextRemoveOpenDatabaseTask::create(this));
+    // In some cases the context initiated this call, so it'll take care of the cleanup by itself, synchronously.  This lets it make sure that the
+    // cleanup completes by a given time.
+    if (removeDatabaseFromContext)
+        m_scriptExecutionContext->postTask(ContextRemoveOpenDatabaseTask::create(this));
 }
 
 void Database::stop()
 {
     // FIXME: The net effect of the following code is to remove all pending transactions and statements, but allow the current statement
     // to run to completion.  In the future we can use the sqlite3_progress_handler or sqlite3_interrupt interfaces to cancel the current
     // statement in response to close(), as well.
 
     // This method is meant to be used as an analog to cancelling a loader, and is used when a document is shut down as the result of
     // a page load or closing the page
@@ skipping 335 matching lines @@
 
 String Database::fileName() const
 {
     // Return a deep copy for ref counting thread safety
     return m_filename.threadsafeCopy();
 }
 
 #endif // ENABLE(DATABASE)
 
 } // namespace WebCore