Web SQL: Make sure DatabaseManager is used only in the main thread.

Source/modules/webdatabase/DatabaseManager.cpp

 /*
  * Copyright (C) 2012 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 30 matching lines @@
 #include "modules/webdatabase/DatabaseClient.h"
 #include "modules/webdatabase/DatabaseContext.h"
 #include "modules/webdatabase/DatabaseServer.h"
 #include "modules/webdatabase/DatabaseTask.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
 namespace blink {
 
 DatabaseManager& DatabaseManager::manager()
 {
-    AtomicallyInitializedStatic(DatabaseManager*, dbManager = new DatabaseManager);
-    return *dbManager;
+    ASSERT(isMainThread());
+    DEFINE_STATIC_LOCAL(DatabaseManager, dbManager, ());
+    return dbManager;
 }
 
 DatabaseManager::DatabaseManager()
 #if ENABLE(ASSERT)
     : m_databaseContextRegisteredCount(0)
     , m_databaseContextInstanceCount(0)
 #endif
 {
     m_server = new DatabaseServer;
     ASSERT(m_server); // We should always have a server to work with.
@@ skipping 21 matching lines @@
         , m_creationCallback(callback)
     {
     }
 
     RefPtrWillBePersistent<Database> m_database;
     OwnPtrWillBePersistent<DatabaseCallback> m_creationCallback;
 };
 
 DatabaseContext* DatabaseManager::existingDatabaseContextFor(ExecutionContext* context)
 {
-    MutexLocker locker(m_contextMapLock);
-
     ASSERT(m_databaseContextRegisteredCount >= 0);
     ASSERT(m_databaseContextInstanceCount >= 0);
     ASSERT(m_databaseContextRegisteredCount <= m_databaseContextInstanceCount);
-#if ENABLE(OILPAN)
-    const Persistent<DatabaseContext>* databaseContext = m_contextMap.get(context);
-    return databaseContext ? databaseContext->get() : 0;
-#else
     return m_contextMap.get(context);
-#endif
 }
 
 DatabaseContext* DatabaseManager::databaseContextFor(ExecutionContext* context)
 {
     if (DatabaseContext* databaseContext = existingDatabaseContextFor(context))
         return databaseContext;
     // We don't need to hold a reference returned by DatabaseContext::create
     // because DatabaseContext::create calls registerDatabaseContext, and the
     // DatabaseManager holds a reference.
     return DatabaseContext::create(context).get();
 }
 
 void DatabaseManager::registerDatabaseContext(DatabaseContext* databaseContext)
 {
-    MutexLocker locker(m_contextMapLock);
     ExecutionContext* context = databaseContext->executionContext();
-#if ENABLE(OILPAN)
-    m_contextMap.set(context, adoptPtr(new Persistent<DatabaseContext>(databaseContext)));
-#else
     m_contextMap.set(context, databaseContext);
-#endif
 #if ENABLE(ASSERT)
     m_databaseContextRegisteredCount++;
 #endif
 }
 
 void DatabaseManager::unregisterDatabaseContext(DatabaseContext* databaseContext)
 {
-    MutexLocker locker(m_contextMapLock);
     ExecutionContext* context = databaseContext->executionContext();
     ASSERT(m_contextMap.get(context));
 #if ENABLE(ASSERT)
     m_databaseContextRegisteredCount--;
 #endif
     m_contextMap.remove(context);
 }
 
 #if ENABLE(ASSERT)
 void DatabaseManager::didConstructDatabaseContext()
 {
-    MutexLocker lock(m_contextMapLock);
     m_databaseContextInstanceCount++;
 }
 
 void DatabaseManager::didDestructDatabaseContext()
 {
-    MutexLocker lock(m_contextMapLock);
     m_databaseContextInstanceCount--;
     ASSERT(m_databaseContextRegisteredCount <= m_databaseContextInstanceCount);
 }
 #endif
 
 void DatabaseManager::throwExceptionForDatabaseError(DatabaseError error, const String& errorMessage, ExceptionState& exceptionState)
 {
     switch (error) {
     case DatabaseError::None:
         return;
@@ skipping 69 matching lines @@
 
     ASSERT(database);
     return database.release();
 }
 
 String DatabaseManager::fullPathForDatabase(SecurityOrigin* origin, const String& name, bool createIfDoesNotExist)
 {
     return m_server->fullPathForDatabase(origin, name, createIfDoesNotExist);
 }
 
-void DatabaseManager::closeDatabasesImmediately(const String& originIdentifier, const String& name)
-{
-    m_server->closeDatabasesImmediately(originIdentifier, name);
-}
-
 void DatabaseManager::logErrorMessage(ExecutionContext* context, const String& message)
 {
     context->addConsoleMessage(ConsoleMessage::create(StorageMessageSource, ErrorMessageLevel, message));
 }
 
 } // namespace blink