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

Only DatabaseManager::closeDatabasesImmediately could be called in non-main
threads. However, it just calls
DatabaseTracker::closeDatabasesImmediately(). This CL removes
DatabaseManager::closeDatabasesImmediately, and only the main thread uses
DatabaseManager.

So, we can remove DatabaseManager::m_contextMapLock.  We still need m_contextMap
because the main thread can have multiple Documents.

Oilpan: We can use PersistentHeapHashMap, and remove some |#if ENABLE(OILPAN)|.

BUG=347902,397429
TEST=No new tests because of no behavior changes.

Review URL: https://codereview.chromium.org/567453002

git-svn-id: svn://svn.chromium.org/blink/trunk@181810 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/modules/webdatabase/AbstractDatabaseServer.h

@@ -46,8 +46,6 @@ public:
         const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize,
         bool setVersionInNewDatabase, DatabaseError&, String& errorMessage) = 0;
 
-    virtual void closeDatabasesImmediately(const String& originIdentifier, const String& name) = 0;
-
 protected:
     AbstractDatabaseServer() { }
     virtual ~AbstractDatabaseServer() { }

third_party/WebKit/Source/modules/webdatabase/DatabaseManager.cpp

@@ -48,8 +48,9 @@ namespace blink {
 
 DatabaseManager& DatabaseManager::manager()
 {
-    AtomicallyInitializedStatic(DatabaseManager*, dbManager = new DatabaseManager);
-    return *dbManager;
+    ASSERT(isMainThread());
+    DEFINE_STATIC_LOCAL(DatabaseManager, dbManager, ());
+    return dbManager;
 }
 
 DatabaseManager::DatabaseManager()
@@ -91,17 +92,10 @@ private:
 
 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)
@@ -116,13 +110,8 @@ DatabaseContext* DatabaseManager::databaseContextFor(ExecutionContext* context)
 
 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
@@ -130,7 +119,6 @@ void DatabaseManager::registerDatabaseContext(DatabaseContext* databaseContext)
 
 void DatabaseManager::unregisterDatabaseContext(DatabaseContext* databaseContext)
 {
-    MutexLocker locker(m_contextMapLock);
     ExecutionContext* context = databaseContext->executionContext();
     ASSERT(m_contextMap.get(context));
 #if ENABLE(ASSERT)
@@ -142,13 +130,11 @@ void DatabaseManager::unregisterDatabaseContext(DatabaseContext* databaseContext
 #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);
 }
@@ -238,11 +224,6 @@ String DatabaseManager::fullPathForDatabase(SecurityOrigin* origin, const String
     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));

third_party/WebKit/Source/modules/webdatabase/DatabaseManager.h

@@ -26,15 +26,13 @@
 #ifndef DatabaseManager_h
 #define DatabaseManager_h
 
-#include "modules/webdatabase/DatabaseBasicTypes.h"
 #include "modules/webdatabase/DatabaseContext.h"
 #include "modules/webdatabase/DatabaseError.h"
 #include "platform/heap/Handle.h"
 #include "wtf/Assertions.h"
+#include "wtf/Forward.h"
 #include "wtf/HashMap.h"
 #include "wtf/PassRefPtr.h"
-#include "wtf/ThreadingPrimitives.h"
-#include "wtf/text/WTFString.h"
 
 namespace blink {
 
@@ -43,13 +41,10 @@ class Database;
 class DatabaseBackendBase;
 class DatabaseCallback;
 class DatabaseContext;
-class TaskSynchronizer;
 class ExceptionState;
 class SecurityOrigin;
 class ExecutionContext;
 
-typedef int ExceptionCode;
-
 class DatabaseManager {
     WTF_MAKE_NONCOPYABLE(DatabaseManager); WTF_MAKE_FAST_ALLOCATED;
 public:
@@ -74,8 +69,6 @@ public:
 
     String fullPathForDatabase(SecurityOrigin*, const String& name, bool createIfDoesNotExist = true);
 
-    void closeDatabasesImmediately(const String& originIdentifier, const String& name);
-
 private:
     DatabaseManager();
     ~DatabaseManager();
@@ -95,21 +88,12 @@ private:
 
     AbstractDatabaseServer* m_server;
 
-    // FIXME: Only one DatabaseContext object can be created. We can remove the
-    // following map, and don't need to worry about locking.
-    // Access to the following fields require locking m_contextMapLock:
-#if ENABLE(OILPAN)
-    // We can't use PersistentHeapHashMap because multiple threads update the map.
-    typedef HashMap<ExecutionContext*, OwnPtr<Persistent<DatabaseContext> > > ContextMap;
-#else
-    typedef HashMap<ExecutionContext*, RefPtr<DatabaseContext> > ContextMap;
-#endif
+    typedef WillBePersistentHeapHashMap<ExecutionContext*, RefPtrWillBeMember<DatabaseContext> > ContextMap;
     ContextMap m_contextMap;
 #if ENABLE(ASSERT)
     int m_databaseContextRegisteredCount;
     int m_databaseContextInstanceCount;
 #endif
-    Mutex m_contextMapLock;
 };
 
 } // namespace blink

third_party/WebKit/Source/modules/webdatabase/DatabaseServer.cpp

@@ -38,11 +38,6 @@ String DatabaseServer::fullPathForDatabase(SecurityOrigin* origin, const String&
     return DatabaseTracker::tracker().fullPathForDatabase(origin, name, createIfDoesNotExist);
 }
 
-void DatabaseServer::closeDatabasesImmediately(const String& originIdentifier, const String& name)
-{
-    DatabaseTracker::tracker().closeDatabasesImmediately(originIdentifier, name);
-}
-
 PassRefPtrWillBeRawPtr<DatabaseBackendBase> DatabaseServer::openDatabase(DatabaseContext* backendContext,
     const String& name, const String& expectedVersion, const String& displayName,
     unsigned long estimatedSize, bool setVersionInNewDatabase, DatabaseError &error, String& errorMessage)

third_party/WebKit/Source/modules/webdatabase/DatabaseServer.h

@@ -42,8 +42,6 @@ public:
         const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize,
         bool setVersionInNewDatabase, DatabaseError&, String& errorMessage) OVERRIDE;
 
-    virtual void closeDatabasesImmediately(const String& originIdentifier, const String& name) OVERRIDE;
-
 protected:
     PassRefPtrWillBeRawPtr<DatabaseBackendBase> createDatabase(DatabaseContext*,
         const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize,

third_party/WebKit/Source/web/WebDatabase.cpp

@@ -32,7 +32,7 @@
 #include "public/web/WebDatabase.h"
 
 #include "modules/webdatabase/DatabaseBackendBase.h"
-#include "modules/webdatabase/DatabaseManager.h"
+#include "modules/webdatabase/DatabaseTracker.h"
 #include "modules/webdatabase/QuotaTracker.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/WebString.h"
@@ -87,7 +87,7 @@ void WebDatabase::resetSpaceAvailable(const WebString& originIdentifier)
 
 void WebDatabase::closeDatabaseImmediately(const WebString& originIdentifier, const WebString& databaseName)
 {
-    DatabaseManager::manager().closeDatabasesImmediately(originIdentifier, databaseName);
+    DatabaseTracker::tracker().closeDatabasesImmediately(originIdentifier, databaseName);
 }
 
 WebDatabase::WebDatabase(const DatabaseBackendBase* database)