DatabaseTrackerChromium.cpp [plain text]
#include "config.h"
#include "DatabaseTracker.h"
#if ENABLE(SQL_DATABASE)
#include "AbstractDatabase.h"
#include "DatabaseObserver.h"
#include "QuotaTracker.h"
#include "PlatformString.h"
#include "ScriptExecutionContext.h"
#include "SecurityOrigin.h"
#include "SecurityOriginHash.h"
#include "SQLiteFileSystem.h"
#include <wtf/StdLibExtras.h>
namespace WebCore {
DatabaseTracker& DatabaseTracker::tracker()
{
AtomicallyInitializedStatic(DatabaseTracker&, tracker = *new DatabaseTracker(""));
return tracker;
}
DatabaseTracker::DatabaseTracker(const String&)
{
SQLiteFileSystem::registerSQLiteVFS();
}
bool DatabaseTracker::canEstablishDatabase(ScriptExecutionContext* scriptExecutionContext, const String& name, const String& displayName, unsigned long estimatedSize)
{
return DatabaseObserver::canEstablishDatabase(scriptExecutionContext, name, displayName, estimatedSize);
}
void DatabaseTracker::setDatabaseDetails(SecurityOrigin*, const String&, const String&, unsigned long)
{
}
String DatabaseTracker::fullPathForDatabase(SecurityOrigin* origin, const String& name, bool)
{
return origin->databaseIdentifier() + "/" + name + "#";
}
void DatabaseTracker::addOpenDatabase(AbstractDatabase* database)
{
ASSERT(database->scriptExecutionContext()->isContextThread());
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
m_openDatabaseMap = adoptPtr(new DatabaseOriginMap);
String originIdentifier = database->securityOrigin()->databaseIdentifier();
DatabaseNameMap* nameMap = m_openDatabaseMap->get(originIdentifier);
if (!nameMap) {
nameMap = new DatabaseNameMap();
m_openDatabaseMap->set(originIdentifier, nameMap);
}
String name(database->stringIdentifier());
DatabaseSet* databaseSet = nameMap->get(name);
if (!databaseSet) {
databaseSet = new DatabaseSet();
nameMap->set(name, databaseSet);
}
databaseSet->add(database);
DatabaseObserver::databaseOpened(database);
}
class NotifyDatabaseObserverOnCloseTask : public ScriptExecutionContext::Task {
public:
static PassOwnPtr<NotifyDatabaseObserverOnCloseTask> create(PassRefPtr<AbstractDatabase> database)
{
return adoptPtr(new NotifyDatabaseObserverOnCloseTask(database));
}
virtual void performTask(ScriptExecutionContext* context)
{
DatabaseObserver::databaseClosed(m_database.get());
}
virtual bool isCleanupTask() const
{
return true;
}
private:
NotifyDatabaseObserverOnCloseTask(PassRefPtr<AbstractDatabase> database)
: m_database(database)
{
}
RefPtr<AbstractDatabase> m_database;
};
void DatabaseTracker::removeOpenDatabase(AbstractDatabase* database)
{
String originIdentifier = database->securityOrigin()->databaseIdentifier();
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
ASSERT(m_openDatabaseMap);
DatabaseNameMap* nameMap = m_openDatabaseMap->get(originIdentifier);
if (!nameMap)
return;
String name(database->stringIdentifier());
DatabaseSet* databaseSet = nameMap->get(name);
if (!databaseSet)
return;
DatabaseSet::iterator found = databaseSet->find(database);
if (found == databaseSet->end())
return;
databaseSet->remove(found);
if (databaseSet->isEmpty()) {
nameMap->remove(name);
delete databaseSet;
if (nameMap->isEmpty()) {
m_openDatabaseMap->remove(originIdentifier);
delete nameMap;
}
}
if (!database->scriptExecutionContext()->isContextThread())
database->scriptExecutionContext()->postTask(NotifyDatabaseObserverOnCloseTask::create(database));
else
DatabaseObserver::databaseClosed(database);
}
unsigned long long DatabaseTracker::getMaxSizeForDatabase(const AbstractDatabase* database)
{
unsigned long long spaceAvailable = 0;
unsigned long long databaseSize = 0;
QuotaTracker::instance().getDatabaseSizeAndSpaceAvailableToOrigin(
database->securityOrigin()->databaseIdentifier(),
database->stringIdentifier(), &databaseSize, &spaceAvailable);
return databaseSize + spaceAvailable;
}
void DatabaseTracker::interruptAllDatabasesForContext(const ScriptExecutionContext* context)
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
return;
DatabaseNameMap* nameMap = m_openDatabaseMap->get(context->securityOrigin()->databaseIdentifier());
if (!nameMap)
return;
DatabaseNameMap::const_iterator dbNameMapEndIt = nameMap->end();
for (DatabaseNameMap::const_iterator dbNameMapIt = nameMap->begin(); dbNameMapIt != dbNameMapEndIt; ++dbNameMapIt) {
DatabaseSet* databaseSet = dbNameMapIt->second;
DatabaseSet::const_iterator end = databaseSet->end();
for (DatabaseSet::const_iterator it = databaseSet->begin(); it != end; ++it) {
if ((*it)->scriptExecutionContext() == context)
(*it)->interrupt();
}
}
}
class DatabaseTracker::CloseOneDatabaseImmediatelyTask : public ScriptExecutionContext::Task {
public:
static PassOwnPtr<CloseOneDatabaseImmediatelyTask> create(const String& originIdentifier, const String& name, AbstractDatabase* database)
{
return adoptPtr(new CloseOneDatabaseImmediatelyTask(originIdentifier, name, database));
}
virtual void performTask(ScriptExecutionContext* context)
{
DatabaseTracker::tracker().closeOneDatabaseImmediately(m_originIdentifier, m_name, m_database);
}
private:
CloseOneDatabaseImmediatelyTask(const String& originIdentifier, const String& name, AbstractDatabase* database)
: m_originIdentifier(originIdentifier.isolatedCopy())
, m_name(name.isolatedCopy())
, m_database(database)
{
}
String m_originIdentifier;
String m_name;
AbstractDatabase* m_database; };
void DatabaseTracker::closeDatabasesImmediately(const String& originIdentifier, const String& name) {
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
return;
DatabaseNameMap* nameMap = m_openDatabaseMap->get(originIdentifier);
if (!nameMap)
return;
DatabaseSet* databaseSet = nameMap->get(name);
if (!databaseSet)
return;
for (DatabaseSet::iterator it = databaseSet->begin(); it != databaseSet->end(); ++it)
(*it)->scriptExecutionContext()->postTask(CloseOneDatabaseImmediatelyTask::create(originIdentifier, name, *it));
}
void DatabaseTracker::closeOneDatabaseImmediately(const String& originIdentifier, const String& name, AbstractDatabase* database)
{
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
return;
DatabaseNameMap* nameMap = m_openDatabaseMap->get(originIdentifier);
if (!nameMap)
return;
DatabaseSet* databaseSet = nameMap->get(name);
if (!databaseSet)
return;
DatabaseSet::iterator found = databaseSet->find(database);
if (found == databaseSet->end())
return;
}
database->closeImmediately();
}
}
#endif // ENABLE(SQL_DATABASE)