DatabaseTracker.cpp [plain text]
#include "config.h"
#include "DatabaseTracker.h"
#if ENABLE(SQL_DATABASE)
#include "Chrome.h"
#include "ChromeClient.h"
#include "Database.h"
#include "DatabaseBackendBase.h"
#include "DatabaseBackendContext.h"
#include "DatabaseManager.h"
#include "DatabaseManagerClient.h"
#include "DatabaseThread.h"
#include "FileSystem.h"
#include "Logging.h"
#include "OriginLock.h"
#include "Page.h"
#include "SecurityOrigin.h"
#include "SecurityOriginHash.h"
#include "SQLiteFileSystem.h"
#include "SQLiteStatement.h"
#include <wtf/MainThread.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/StdLibExtras.h>
#include <wtf/text/CString.h>
#if PLATFORM(IOS)
#include "WebCoreThread.h"
#endif
namespace WebCore {
static DatabaseTracker* staticTracker = 0;
void DatabaseTracker::initializeTracker(const String& databasePath)
{
ASSERT(!staticTracker);
if (staticTracker)
return;
staticTracker = new DatabaseTracker(databasePath);
}
DatabaseTracker& DatabaseTracker::tracker()
{
if (!staticTracker)
staticTracker = new DatabaseTracker("");
return *staticTracker;
}
DatabaseTracker::DatabaseTracker(const String& databasePath)
: m_client(0)
{
setDatabaseDirectoryPath(databasePath);
}
void DatabaseTracker::setDatabaseDirectoryPath(const String& path)
{
MutexLocker lockDatabase(m_databaseGuard);
ASSERT(!m_database.isOpen());
m_databaseDirectoryPath = path.isolatedCopy();
}
String DatabaseTracker::databaseDirectoryPath() const
{
return m_databaseDirectoryPath.isolatedCopy();
}
String DatabaseTracker::trackerDatabasePath() const
{
return SQLiteFileSystem::appendDatabaseFileNameToPath(m_databaseDirectoryPath.isolatedCopy(), "Databases.db");
}
void DatabaseTracker::openTrackerDatabase(TrackerCreationAction createAction)
{
ASSERT(!m_databaseGuard.tryLock());
if (m_database.isOpen())
return;
String databasePath = trackerDatabasePath();
if (!SQLiteFileSystem::ensureDatabaseFileExists(databasePath, createAction == CreateIfDoesNotExist))
return;
if (!m_database.open(databasePath)) {
LOG_ERROR("Failed to open databasePath %s.", databasePath.ascii().data());
return;
}
m_database.disableThreadingChecks();
if (!m_database.tableExists("Origins")) {
if (!m_database.executeCommand("CREATE TABLE Origins (origin TEXT UNIQUE ON CONFLICT REPLACE, quota INTEGER NOT NULL ON CONFLICT FAIL);")) {
LOG_ERROR("Failed to create Origins table");
}
}
if (!m_database.tableExists("Databases")) {
if (!m_database.executeCommand("CREATE TABLE Databases (guid INTEGER PRIMARY KEY AUTOINCREMENT, origin TEXT, name TEXT, displayName TEXT, estimatedSize INTEGER, path TEXT);")) {
LOG_ERROR("Failed to create Databases table");
}
}
}
bool DatabaseTracker::hasAdequateQuotaForOrigin(SecurityOrigin* origin, unsigned long estimatedSize, DatabaseError& err)
{
ASSERT(!m_databaseGuard.tryLock());
unsigned long long usage = usageForOrigin(origin);
unsigned long long requirement = usage + std::max<unsigned long long>(1, estimatedSize);
if (requirement < usage) {
err = DatabaseError::DatabaseSizeOverflowed;
return false;
}
if (requirement <= quotaForOriginNoLock(origin))
return true;
err = DatabaseError::DatabaseSizeExceededQuota;
return false;
}
bool DatabaseTracker::canEstablishDatabase(DatabaseBackendContext* context, const String& name, unsigned long estimatedSize, DatabaseError& error)
{
error = DatabaseError::None;
MutexLocker lockDatabase(m_databaseGuard);
SecurityOrigin* origin = context->securityOrigin();
if (isDeletingDatabaseOrOriginFor(origin, name)) {
error = DatabaseError::DatabaseIsBeingDeleted;
return false;
}
recordCreatingDatabase(origin, name);
if (hasEntryForDatabase(origin, name))
return true;
if (hasAdequateQuotaForOrigin(origin, estimatedSize, error)) {
ASSERT(error == DatabaseError::None);
return true;
}
if (error == DatabaseError::DatabaseSizeOverflowed)
doneCreatingDatabase(origin, name);
else
ASSERT(error == DatabaseError::DatabaseSizeExceededQuota);
return false;
}
bool DatabaseTracker::retryCanEstablishDatabase(DatabaseBackendContext* context, const String& name, unsigned long estimatedSize, DatabaseError& error)
{
error = DatabaseError::None;
MutexLocker lockDatabase(m_databaseGuard);
SecurityOrigin* origin = context->securityOrigin();
if (hasAdequateQuotaForOrigin(origin, estimatedSize, error)) {
ASSERT(error == DatabaseError::None);
return true;
}
ASSERT(error == DatabaseError::DatabaseSizeExceededQuota);
doneCreatingDatabase(origin, name);
return false;
}
bool DatabaseTracker::hasEntryForOriginNoLock(SecurityOrigin* origin)
{
ASSERT(!m_databaseGuard.tryLock());
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen())
return false;
SQLiteStatement statement(m_database, "SELECT origin FROM Origins where origin=?;");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Failed to prepare statement.");
return false;
}
statement.bindText(1, origin->databaseIdentifier());
return statement.step() == SQLResultRow;
}
bool DatabaseTracker::hasEntryForOrigin(SecurityOrigin* origin)
{
MutexLocker lockDatabase(m_databaseGuard);
return hasEntryForOriginNoLock(origin);
}
bool DatabaseTracker::hasEntryForDatabase(SecurityOrigin* origin, const String& databaseIdentifier)
{
ASSERT(!m_databaseGuard.tryLock());
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen()) {
return false;
}
SQLiteStatement statement(m_database, "SELECT guid FROM Databases WHERE origin=? AND name=?;");
if (statement.prepare() != SQLResultOk)
return false;
statement.bindText(1, origin->databaseIdentifier());
statement.bindText(2, databaseIdentifier);
return statement.step() == SQLResultRow;
}
unsigned long long DatabaseTracker::getMaxSizeForDatabase(const DatabaseBackendBase* database)
{
MutexLocker lockDatabase(m_databaseGuard);
SecurityOrigin* origin = database->securityOrigin();
unsigned long long quota = quotaForOriginNoLock(origin);
unsigned long long diskUsage = usageForOrigin(origin);
unsigned long long databaseFileSize = SQLiteFileSystem::getDatabaseFileSize(database->fileName());
ASSERT(databaseFileSize <= diskUsage);
if (diskUsage > quota)
return databaseFileSize;
unsigned long long maxSize = quota - diskUsage + databaseFileSize;
if (maxSize > quota)
maxSize = databaseFileSize;
return maxSize;
}
void DatabaseTracker::interruptAllDatabasesForContext(const DatabaseBackendContext* context)
{
Vector<RefPtr<DatabaseBackendBase>> openDatabases;
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
return;
DatabaseNameMap* nameMap = m_openDatabaseMap->get(context->securityOrigin());
if (!nameMap)
return;
DatabaseNameMap::const_iterator dbNameMapEndIt = nameMap->end();
for (DatabaseNameMap::const_iterator dbNameMapIt = nameMap->begin(); dbNameMapIt != dbNameMapEndIt; ++dbNameMapIt) {
DatabaseSet* databaseSet = dbNameMapIt->value;
DatabaseSet::const_iterator dbSetEndIt = databaseSet->end();
for (DatabaseSet::const_iterator dbSetIt = databaseSet->begin(); dbSetIt != dbSetEndIt; ++dbSetIt) {
if ((*dbSetIt)->databaseContext() == context)
openDatabases.append(*dbSetIt);
}
}
}
Vector<RefPtr<DatabaseBackendBase>>::const_iterator openDatabasesEndIt = openDatabases.end();
for (Vector<RefPtr<DatabaseBackendBase>>::const_iterator openDatabasesIt = openDatabases.begin(); openDatabasesIt != openDatabasesEndIt; ++openDatabasesIt)
(*openDatabasesIt)->interrupt();
}
String DatabaseTracker::originPath(SecurityOrigin* origin) const
{
return SQLiteFileSystem::appendDatabaseFileNameToPath(m_databaseDirectoryPath.isolatedCopy(), origin->databaseIdentifier());
}
String DatabaseTracker::fullPathForDatabaseNoLock(SecurityOrigin* origin, const String& name, bool createIfNotExists)
{
ASSERT(!m_databaseGuard.tryLock());
String originIdentifier = origin->databaseIdentifier();
String originPath = this->originPath(origin);
if (createIfNotExists && !SQLiteFileSystem::ensureDatabaseDirectoryExists(originPath))
return String();
if (!m_database.isOpen())
return String();
SQLiteStatement statement(m_database, "SELECT path FROM Databases WHERE origin=? AND name=?;");
if (statement.prepare() != SQLResultOk)
return String();
statement.bindText(1, originIdentifier);
statement.bindText(2, name);
int result = statement.step();
if (result == SQLResultRow)
return SQLiteFileSystem::appendDatabaseFileNameToPath(originPath, statement.getColumnText(0));
if (!createIfNotExists)
return String();
if (result != SQLResultDone) {
LOG_ERROR("Failed to retrieve filename from Database Tracker for origin %s, name %s", originIdentifier.ascii().data(), name.ascii().data());
return String();
}
statement.finalize();
String fileName = SQLiteFileSystem::getFileNameForNewDatabase(originPath, name, originIdentifier, &m_database);
if (!addDatabase(origin, name, fileName))
return String();
String fullFilePath = SQLiteFileSystem::appendDatabaseFileNameToPath(originPath, fileName);
return fullFilePath;
}
String DatabaseTracker::fullPathForDatabase(SecurityOrigin* origin, const String& name, bool createIfNotExists)
{
MutexLocker lockDatabase(m_databaseGuard);
return fullPathForDatabaseNoLock(origin, name, createIfNotExists).isolatedCopy();
}
void DatabaseTracker::origins(Vector<RefPtr<SecurityOrigin>>& originsResult)
{
MutexLocker lockDatabase(m_databaseGuard);
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen())
return;
SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Failed to prepare statement.");
return;
}
int result;
while ((result = statement.step()) == SQLResultRow) {
RefPtr<SecurityOrigin> origin = SecurityOrigin::createFromDatabaseIdentifier(statement.getColumnText(0));
originsResult.append(origin->isolatedCopy());
}
originsResult.shrinkToFit();
if (result != SQLResultDone)
LOG_ERROR("Failed to read in all origins from the database.");
}
bool DatabaseTracker::databaseNamesForOriginNoLock(SecurityOrigin* origin, Vector<String>& resultVector)
{
ASSERT(!m_databaseGuard.tryLock());
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen())
return false;
SQLiteStatement statement(m_database, "SELECT name FROM Databases where origin=?;");
if (statement.prepare() != SQLResultOk)
return false;
statement.bindText(1, origin->databaseIdentifier());
int result;
while ((result = statement.step()) == SQLResultRow)
resultVector.append(statement.getColumnText(0));
if (result != SQLResultDone) {
LOG_ERROR("Failed to retrieve all database names for origin %s", origin->databaseIdentifier().ascii().data());
return false;
}
return true;
}
bool DatabaseTracker::databaseNamesForOrigin(SecurityOrigin* origin, Vector<String>& resultVector)
{
Vector<String> temp;
{
MutexLocker lockDatabase(m_databaseGuard);
if (!databaseNamesForOriginNoLock(origin, temp))
return false;
}
for (Vector<String>::iterator iter = temp.begin(); iter != temp.end(); ++iter)
resultVector.append(iter->isolatedCopy());
return true;
}
DatabaseDetails DatabaseTracker::detailsForNameAndOrigin(const String& name, SecurityOrigin* origin)
{
String originIdentifier = origin->databaseIdentifier();
String displayName;
int64_t expectedUsage;
{
MutexLocker lockDatabase(m_databaseGuard);
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen())
return DatabaseDetails();
SQLiteStatement statement(m_database, "SELECT displayName, estimatedSize FROM Databases WHERE origin=? AND name=?");
if (statement.prepare() != SQLResultOk)
return DatabaseDetails();
statement.bindText(1, originIdentifier);
statement.bindText(2, name);
int result = statement.step();
if (result == SQLResultDone)
return DatabaseDetails();
if (result != SQLResultRow) {
LOG_ERROR("Error retrieving details for database %s in origin %s from tracker database", name.ascii().data(), originIdentifier.ascii().data());
return DatabaseDetails();
}
displayName = statement.getColumnText(0);
expectedUsage = statement.getColumnInt64(1);
}
String path = fullPathForDatabase(origin, name, false);
if (path.isEmpty())
return DatabaseDetails(name, displayName, expectedUsage, 0, 0, 0);
return DatabaseDetails(name, displayName, expectedUsage, SQLiteFileSystem::getDatabaseFileSize(path), SQLiteFileSystem::databaseCreationTime(path), SQLiteFileSystem::databaseModificationTime(path));
}
void DatabaseTracker::setDatabaseDetails(SecurityOrigin* origin, const String& name, const String& displayName, unsigned long estimatedSize)
{
String originIdentifier = origin->databaseIdentifier();
int64_t guid = 0;
MutexLocker lockDatabase(m_databaseGuard);
openTrackerDatabase(CreateIfDoesNotExist);
if (!m_database.isOpen())
return;
SQLiteStatement statement(m_database, "SELECT guid FROM Databases WHERE origin=? AND name=?");
if (statement.prepare() != SQLResultOk)
return;
statement.bindText(1, originIdentifier);
statement.bindText(2, name);
int result = statement.step();
if (result == SQLResultRow)
guid = statement.getColumnInt64(0);
statement.finalize();
if (guid == 0) {
if (result != SQLResultDone)
LOG_ERROR("Error to determing existence of database %s in origin %s in tracker database", name.ascii().data(), originIdentifier.ascii().data());
else {
LOG_ERROR("Could not retrieve guid for database %s in origin %s from the tracker database - it is invalid to set database details on a database that doesn't already exist in the tracker",
name.ascii().data(), originIdentifier.ascii().data());
}
return;
}
SQLiteStatement updateStatement(m_database, "UPDATE Databases SET displayName=?, estimatedSize=? WHERE guid=?");
if (updateStatement.prepare() != SQLResultOk)
return;
updateStatement.bindText(1, displayName);
updateStatement.bindInt64(2, estimatedSize);
updateStatement.bindInt64(3, guid);
if (updateStatement.step() != SQLResultDone) {
LOG_ERROR("Failed to update details for database %s in origin %s", name.ascii().data(), originIdentifier.ascii().data());
return;
}
if (m_client)
m_client->dispatchDidModifyDatabase(origin, name);
}
void DatabaseTracker::doneCreatingDatabase(DatabaseBackendBase* database)
{
MutexLocker lockDatabase(m_databaseGuard);
doneCreatingDatabase(database->securityOrigin(), database->stringIdentifier());
}
void DatabaseTracker::addOpenDatabase(DatabaseBackendBase* database)
{
if (!database)
return;
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
m_openDatabaseMap = std::make_unique<DatabaseOriginMap>();
String name(database->stringIdentifier());
DatabaseNameMap* nameMap = m_openDatabaseMap->get(database->securityOrigin());
if (!nameMap) {
nameMap = new DatabaseNameMap;
m_openDatabaseMap->set(database->securityOrigin()->isolatedCopy(), nameMap);
}
DatabaseSet* databaseSet = nameMap->get(name);
if (!databaseSet) {
databaseSet = new DatabaseSet;
nameMap->set(name.isolatedCopy(), databaseSet);
}
databaseSet->add(database);
LOG(StorageAPI, "Added open Database %s (%p)\n", database->stringIdentifier().ascii().data(), database);
}
}
void DatabaseTracker::removeOpenDatabase(DatabaseBackendBase* database)
{
if (!database)
return;
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap) {
ASSERT_NOT_REACHED();
return;
}
String name(database->stringIdentifier());
DatabaseNameMap* nameMap = m_openDatabaseMap->get(database->securityOrigin());
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(database->securityOrigin());
delete nameMap;
}
}
void DatabaseTracker::getOpenDatabases(SecurityOrigin* origin, const String& name, HashSet<RefPtr<DatabaseBackendBase>>* databases)
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
return;
DatabaseNameMap* nameMap = m_openDatabaseMap->get(origin);
if (!nameMap)
return;
DatabaseSet* databaseSet = nameMap->get(name);
if (!databaseSet)
return;
for (DatabaseSet::iterator it = databaseSet->begin(); it != databaseSet->end(); ++it)
databases->add(*it);
}
PassRefPtr<OriginLock> DatabaseTracker::originLockFor(SecurityOrigin* origin)
{
MutexLocker lockDatabase(m_databaseGuard);
String databaseIdentifier = origin->databaseIdentifier();
databaseIdentifier = databaseIdentifier.isolatedCopy();
OriginLockMap::AddResult addResult =
m_originLockMap.add(databaseIdentifier, RefPtr<OriginLock>());
if (!addResult.isNewEntry)
return addResult.iterator->value;
String path = originPath(origin);
RefPtr<OriginLock> lock = adoptRef(new OriginLock(path));
ASSERT(lock);
addResult.iterator->value = lock;
return lock.release();
}
void DatabaseTracker::deleteOriginLockFor(SecurityOrigin* origin)
{
ASSERT(!m_databaseGuard.tryLock());
m_originLockMap.remove(origin->databaseIdentifier());
OriginLock::deleteLockFile(originPath(origin));
}
unsigned long long DatabaseTracker::usageForOrigin(SecurityOrigin* origin)
{
String originPath = this->originPath(origin);
unsigned long long diskUsage = 0;
Vector<String> fileNames = listDirectory(originPath, String("*.db"));
Vector<String>::iterator fileName = fileNames.begin();
Vector<String>::iterator lastFileName = fileNames.end();
for (; fileName != lastFileName; ++fileName) {
long long size;
getFileSize(*fileName, size);
diskUsage += size;
}
return diskUsage;
}
unsigned long long DatabaseTracker::quotaForOriginNoLock(SecurityOrigin* origin)
{
ASSERT(!m_databaseGuard.tryLock());
unsigned long long quota = 0;
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen())
return quota;
SQLiteStatement statement(m_database, "SELECT quota FROM Origins where origin=?;");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Failed to prepare statement.");
return quota;
}
statement.bindText(1, origin->databaseIdentifier());
if (statement.step() == SQLResultRow)
quota = statement.getColumnInt64(0);
return quota;
}
unsigned long long DatabaseTracker::quotaForOrigin(SecurityOrigin* origin)
{
MutexLocker lockDatabase(m_databaseGuard);
return quotaForOriginNoLock(origin);
}
void DatabaseTracker::setQuota(SecurityOrigin* origin, unsigned long long quota)
{
MutexLocker lockDatabase(m_databaseGuard);
if (quotaForOriginNoLock(origin) == quota)
return;
openTrackerDatabase(CreateIfDoesNotExist);
if (!m_database.isOpen())
return;
#if PLATFORM(IOS)
bool insertedNewOrigin = false;
#endif
bool originEntryExists = hasEntryForOriginNoLock(origin);
if (!originEntryExists) {
SQLiteStatement statement(m_database, "INSERT INTO Origins VALUES (?, ?)");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Unable to establish origin %s in the tracker", origin->databaseIdentifier().ascii().data());
} else {
statement.bindText(1, origin->databaseIdentifier());
statement.bindInt64(2, quota);
if (statement.step() != SQLResultDone)
LOG_ERROR("Unable to establish origin %s in the tracker", origin->databaseIdentifier().ascii().data());
#if PLATFORM(IOS)
else
insertedNewOrigin = true;
#endif
}
} else {
SQLiteStatement statement(m_database, "UPDATE Origins SET quota=? WHERE origin=?");
bool error = statement.prepare() != SQLResultOk;
if (!error) {
statement.bindInt64(1, quota);
statement.bindText(2, origin->databaseIdentifier());
error = !statement.executeCommand();
}
if (error)
LOG_ERROR("Failed to set quota %llu in tracker database for origin %s", quota, origin->databaseIdentifier().ascii().data());
}
if (m_client)
#if PLATFORM(IOS)
{
if (insertedNewOrigin)
m_client->dispatchDidAddNewOrigin(origin);
#endif
m_client->dispatchDidModifyOrigin(origin);
#if PLATFORM(IOS)
}
#endif
}
bool DatabaseTracker::addDatabase(SecurityOrigin* origin, const String& name, const String& path)
{
ASSERT(!m_databaseGuard.tryLock());
openTrackerDatabase(CreateIfDoesNotExist);
if (!m_database.isOpen())
return false;
ASSERT(hasEntryForOriginNoLock(origin));
SQLiteStatement statement(m_database, "INSERT INTO Databases (origin, name, path) VALUES (?, ?, ?);");
if (statement.prepare() != SQLResultOk)
return false;
statement.bindText(1, origin->databaseIdentifier());
statement.bindText(2, name);
statement.bindText(3, path);
if (!statement.executeCommand()) {
LOG_ERROR("Failed to add database %s to origin %s: %s\n", name.ascii().data(), origin->databaseIdentifier().ascii().data(), m_database.lastErrorMsg());
return false;
}
if (m_client)
m_client->dispatchDidModifyOrigin(origin);
return true;
}
void DatabaseTracker::deleteAllDatabases()
{
Vector<RefPtr<SecurityOrigin>> originsCopy;
origins(originsCopy);
for (unsigned i = 0; i < originsCopy.size(); ++i)
deleteOrigin(originsCopy[i].get());
}
bool DatabaseTracker::deleteOrigin(SecurityOrigin* origin)
{
Vector<String> databaseNames;
{
MutexLocker lockDatabase(m_databaseGuard);
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen())
return false;
if (!databaseNamesForOriginNoLock(origin, databaseNames)) {
LOG_ERROR("Unable to retrieve list of database names for origin %s", origin->databaseIdentifier().ascii().data());
return false;
}
if (!canDeleteOrigin(origin)) {
LOG_ERROR("Tried to delete an origin (%s) while either creating database in it or already deleting it", origin->databaseIdentifier().ascii().data());
ASSERT_NOT_REACHED();
return false;
}
recordDeletingOrigin(origin);
}
for (unsigned i = 0; i < databaseNames.size(); ++i) {
if (!deleteDatabaseFile(origin, databaseNames[i])) {
LOG_ERROR("Unable to delete file for database %s in origin %s", databaseNames[i].ascii().data(), origin->databaseIdentifier().ascii().data());
}
}
{
MutexLocker lockDatabase(m_databaseGuard);
deleteOriginLockFor(origin);
doneDeletingOrigin(origin);
SQLiteStatement statement(m_database, "DELETE FROM Databases WHERE origin=?");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Unable to prepare deletion of databases from origin %s from tracker", origin->databaseIdentifier().ascii().data());
return false;
}
statement.bindText(1, origin->databaseIdentifier());
if (!statement.executeCommand()) {
LOG_ERROR("Unable to execute deletion of databases from origin %s from tracker", origin->databaseIdentifier().ascii().data());
return false;
}
SQLiteStatement originStatement(m_database, "DELETE FROM Origins WHERE origin=?");
if (originStatement.prepare() != SQLResultOk) {
LOG_ERROR("Unable to prepare deletion of origin %s from tracker", origin->databaseIdentifier().ascii().data());
return false;
}
originStatement.bindText(1, origin->databaseIdentifier());
if (!originStatement.executeCommand()) {
LOG_ERROR("Unable to execute deletion of databases from origin %s from tracker", origin->databaseIdentifier().ascii().data());
return false;
}
SQLiteFileSystem::deleteEmptyDatabaseDirectory(originPath(origin));
RefPtr<SecurityOrigin> originPossiblyLastReference = origin;
bool isEmpty = true;
openTrackerDatabase(DontCreateIfDoesNotExist);
if (m_database.isOpen()) {
SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
if (statement.prepare() != SQLResultOk)
LOG_ERROR("Failed to prepare statement.");
else if (statement.step() == SQLResultRow)
isEmpty = false;
}
if (isEmpty) {
if (m_database.isOpen())
m_database.close();
SQLiteFileSystem::deleteDatabaseFile(trackerDatabasePath());
SQLiteFileSystem::deleteEmptyDatabaseDirectory(m_databaseDirectoryPath);
}
if (m_client) {
m_client->dispatchDidModifyOrigin(origin);
#if PLATFORM(IOS)
m_client->dispatchDidDeleteDatabaseOrigin();
#endif
for (unsigned i = 0; i < databaseNames.size(); ++i)
m_client->dispatchDidModifyDatabase(origin, databaseNames[i]);
}
}
return true;
}
bool DatabaseTracker::isDeletingDatabaseOrOriginFor(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
return isDeletingDatabase(origin, name) || isDeletingOrigin(origin);
}
void DatabaseTracker::recordCreatingDatabase(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
NameCountMap* nameMap = m_beingCreated.get(origin);
if (!nameMap) {
nameMap = new NameCountMap();
m_beingCreated.set(origin->isolatedCopy(), nameMap);
}
long count = nameMap->get(name);
nameMap->set(name.isolatedCopy(), count + 1);
}
void DatabaseTracker::doneCreatingDatabase(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
NameCountMap* nameMap = m_beingCreated.get(origin);
ASSERT(nameMap);
if (!nameMap)
return;
long count = nameMap->get(name);
ASSERT(count > 0);
if (count <= 1) {
nameMap->remove(name);
if (nameMap->isEmpty()) {
m_beingCreated.remove(origin);
delete nameMap;
}
} else
nameMap->set(name, count - 1);
}
bool DatabaseTracker::creatingDatabase(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
NameCountMap* nameMap = m_beingCreated.get(origin);
return nameMap && nameMap->get(name);
}
bool DatabaseTracker::canDeleteDatabase(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
return !creatingDatabase(origin, name) && !isDeletingDatabase(origin, name);
}
void DatabaseTracker::recordDeletingDatabase(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
ASSERT(canDeleteDatabase(origin, name));
NameSet* nameSet = m_beingDeleted.get(origin);
if (!nameSet) {
nameSet = new NameSet();
m_beingDeleted.set(origin->isolatedCopy(), nameSet);
}
ASSERT(!nameSet->contains(name));
nameSet->add(name.isolatedCopy());
}
void DatabaseTracker::doneDeletingDatabase(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
NameSet* nameSet = m_beingDeleted.get(origin);
ASSERT(nameSet);
if (!nameSet)
return;
ASSERT(nameSet->contains(name));
nameSet->remove(name);
if (nameSet->isEmpty()) {
m_beingDeleted.remove(origin);
delete nameSet;
}
}
bool DatabaseTracker::isDeletingDatabase(SecurityOrigin *origin, const String& name)
{
ASSERT(!m_databaseGuard.tryLock());
NameSet* nameSet = m_beingDeleted.get(origin);
return nameSet && nameSet->contains(name);
}
bool DatabaseTracker::canDeleteOrigin(SecurityOrigin *origin)
{
ASSERT(!m_databaseGuard.tryLock());
return !(isDeletingOrigin(origin) || m_beingCreated.get(origin));
}
bool DatabaseTracker::isDeletingOrigin(SecurityOrigin *origin)
{
ASSERT(!m_databaseGuard.tryLock());
return m_originsBeingDeleted.contains(origin);
}
void DatabaseTracker::recordDeletingOrigin(SecurityOrigin *origin)
{
ASSERT(!m_databaseGuard.tryLock());
ASSERT(!isDeletingOrigin(origin));
m_originsBeingDeleted.add(origin->isolatedCopy());
}
void DatabaseTracker::doneDeletingOrigin(SecurityOrigin *origin)
{
ASSERT(!m_databaseGuard.tryLock());
ASSERT(isDeletingOrigin(origin));
m_originsBeingDeleted.remove(origin);
}
bool DatabaseTracker::deleteDatabase(SecurityOrigin* origin, const String& name)
{
{
MutexLocker lockDatabase(m_databaseGuard);
openTrackerDatabase(DontCreateIfDoesNotExist);
if (!m_database.isOpen())
return false;
if (!canDeleteDatabase(origin, name)) {
ASSERT_NOT_REACHED();
return false;
}
recordDeletingDatabase(origin, name);
}
if (!deleteDatabaseFile(origin, name)) {
LOG_ERROR("Unable to delete file for database %s in origin %s", name.ascii().data(), origin->databaseIdentifier().ascii().data());
MutexLocker lockDatabase(m_databaseGuard);
doneDeletingDatabase(origin, name);
return false;
}
MutexLocker lockDatabase(m_databaseGuard);
SQLiteStatement statement(m_database, "DELETE FROM Databases WHERE origin=? AND name=?");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Unable to prepare deletion of database %s from origin %s from tracker", name.ascii().data(), origin->databaseIdentifier().ascii().data());
doneDeletingDatabase(origin, name);
return false;
}
statement.bindText(1, origin->databaseIdentifier());
statement.bindText(2, name);
if (!statement.executeCommand()) {
LOG_ERROR("Unable to execute deletion of database %s from origin %s from tracker", name.ascii().data(), origin->databaseIdentifier().ascii().data());
doneDeletingDatabase(origin, name);
return false;
}
if (m_client) {
m_client->dispatchDidModifyOrigin(origin);
m_client->dispatchDidModifyDatabase(origin, name);
#if PLATFORM(IOS)
m_client->dispatchDidDeleteDatabase();
#endif
}
doneDeletingDatabase(origin, name);
return true;
}
bool DatabaseTracker::deleteDatabaseFile(SecurityOrigin* origin, const String& name)
{
String fullPath = fullPathForDatabase(origin, name, false);
if (fullPath.isEmpty())
return true;
#ifndef NDEBUG
{
MutexLocker lockDatabase(m_databaseGuard);
ASSERT(isDeletingDatabaseOrOriginFor(origin, name));
}
#endif
Vector<RefPtr<DatabaseBackendBase>> deletedDatabases;
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (m_openDatabaseMap) {
DatabaseNameMap* nameMap = m_openDatabaseMap->get(origin);
if (nameMap && nameMap->size()) {
DatabaseSet* databaseSet = nameMap->get(name);
if (databaseSet && databaseSet->size()) {
DatabaseSet::const_iterator end = databaseSet->end();
for (DatabaseSet::const_iterator it = databaseSet->begin(); it != end; ++it)
deletedDatabases.append(*it);
}
}
}
}
for (unsigned i = 0; i < deletedDatabases.size(); ++i)
deletedDatabases[i]->markAsDeletedAndClose();
#if !PLATFORM(IOS)
return SQLiteFileSystem::deleteDatabaseFile(fullPath);
#else
SQLiteDatabase database;
if (database.open(fullPath))
return SQLiteFileSystem::truncateDatabaseFile(database.sqlite3Handle());
return false;
#endif
}
#if PLATFORM(IOS)
void DatabaseTracker::removeDeletedOpenedDatabases()
{
{
MutexLocker lockDatabase(m_databaseGuard);
openTrackerDatabase(DontCreateIfDoesNotExist);
}
if (!m_database.isOpen())
return;
Vector<RefPtr<Database> > deletedDatabases;
typedef HashMap<RefPtr<SecurityOrigin>, Vector<String> > DeletedDatabaseMap;
DeletedDatabaseMap deletedDatabaseMap;
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (m_openDatabaseMap) {
DatabaseOriginMap::const_iterator originMapEnd = m_openDatabaseMap->end();
for (DatabaseOriginMap::const_iterator originMapIt = m_openDatabaseMap->begin(); originMapIt != originMapEnd; ++originMapIt) {
RefPtr<SecurityOrigin> origin = originMapIt->key;
DatabaseNameMap* databaseNameMap = originMapIt->value;
Vector<String> deletedDatabaseNamesForThisOrigin;
DatabaseNameMap::const_iterator dbNameMapEnd = databaseNameMap->end();
for (DatabaseNameMap::const_iterator dbNameMapIt = databaseNameMap->begin(); dbNameMapIt != dbNameMapEnd; ++dbNameMapIt) {
String databaseName = dbNameMapIt->key;
String databaseFileName;
SQLiteStatement statement(m_database, "SELECT path FROM Databases WHERE origin=? AND name=?;");
if (statement.prepare() == SQLResultOk) {
statement.bindText(1, origin->databaseIdentifier());
statement.bindText(2, databaseName);
if (statement.step() == SQLResultRow)
databaseFileName = statement.getColumnText(0);
statement.finalize();
}
bool foundDeletedDatabase = false;
DatabaseSet* databaseSet = dbNameMapIt->value;
DatabaseSet::const_iterator dbEnd = databaseSet->end();
for (DatabaseSet::const_iterator dbIt = databaseSet->begin(); dbIt != dbEnd; ++dbIt) {
Database* db = static_cast<Database*>(*dbIt);
if (db->deleted())
continue;
if (databaseFileName.isNull() || databaseFileName != pathGetFileName(db->fileName())) {
deletedDatabases.append(db);
foundDeletedDatabase = true;
}
}
if (foundDeletedDatabase && databaseFileName.isNull())
deletedDatabaseNamesForThisOrigin.append(databaseName);
}
if (!deletedDatabaseNamesForThisOrigin.isEmpty())
deletedDatabaseMap.set(origin, deletedDatabaseNamesForThisOrigin);
}
}
}
for (unsigned i = 0; i < deletedDatabases.size(); ++i)
deletedDatabases[i]->markAsDeletedAndClose();
DeletedDatabaseMap::const_iterator end = deletedDatabaseMap.end();
for (DeletedDatabaseMap::const_iterator it = deletedDatabaseMap.begin(); it != end; ++it) {
SecurityOrigin* origin = it->key.get();
if (m_client)
m_client->dispatchDidModifyOrigin(origin);
const Vector<String>& databaseNames = it->value;
for (unsigned i = 0; i < databaseNames.size(); ++i) {
if (m_client)
m_client->dispatchDidModifyDatabase(origin, databaseNames[i]);
}
}
}
static bool isZeroByteFile(const String& path)
{
long long size = 0;
return getFileSize(path, size) && !size;
}
bool DatabaseTracker::deleteDatabaseFileIfEmpty(const String& path)
{
if (!isZeroByteFile(path))
return false;
SQLiteDatabase database;
if (!database.open(path))
return false;
SQLiteStatement lockStatement(database, "PRAGMA locking_mode=EXCLUSIVE;");
if (lockStatement.prepare() != SQLResultOk)
return false;
int result = lockStatement.step();
if (result != SQLResultRow && result != SQLResultDone)
return false;
lockStatement.finalize();
SQLiteStatement readStatement(database, "SELECT * FROM sqlite_master LIMIT 1;");
if (readStatement.prepare() != SQLResultOk)
return false;
if (readStatement.step() != SQLResultDone)
return false;
readStatement.finalize();
if (!isZeroByteFile(path))
return false;
return SQLiteFileSystem::deleteDatabaseFile(path);
}
Mutex& DatabaseTracker::openDatabaseMutex()
{
static NeverDestroyed<Mutex> mutex;
return mutex;
}
void DatabaseTracker::emptyDatabaseFilesRemovalTaskWillBeScheduled()
{
openDatabaseMutex().lock();
}
void DatabaseTracker::emptyDatabaseFilesRemovalTaskDidFinish()
{
openDatabaseMutex().unlock();
}
void DatabaseTracker::setDatabasesPaused(bool paused)
{
MutexLocker openDatabaseMapLock(m_openDatabaseMapGuard);
if (!m_openDatabaseMap)
return;
DatabaseOriginMap::iterator i = m_openDatabaseMap.get()->begin();
DatabaseOriginMap::iterator end = m_openDatabaseMap.get()->end();
for (; i != end; ++i) {
DatabaseNameMap* databaseNameMap = i->value;
DatabaseNameMap::iterator j = databaseNameMap->begin();
DatabaseNameMap::iterator dbNameMapEnd = databaseNameMap->end();
for (; j != dbNameMapEnd; ++j) {
DatabaseSet* databaseSet = j->value;
DatabaseSet::iterator k = databaseSet->begin();
DatabaseSet::iterator dbSetEnd = databaseSet->end();
for (; k != dbSetEnd; ++k) {
DatabaseContext* context = (*k)->databaseContext();
context->setPaused(paused);
}
}
}
}
#endif
void DatabaseTracker::setClient(DatabaseManagerClient* client)
{
m_client = client;
}
static Mutex& notificationMutex()
{
static NeverDestroyed<Mutex> mutex;
return mutex;
}
typedef Vector<std::pair<RefPtr<SecurityOrigin>, String>> NotificationQueue;
static NotificationQueue& notificationQueue()
{
static NeverDestroyed<NotificationQueue> queue;
return queue;
}
void DatabaseTracker::scheduleNotifyDatabaseChanged(SecurityOrigin* origin, const String& name)
{
MutexLocker locker(notificationMutex());
notificationQueue().append(std::pair<RefPtr<SecurityOrigin>, String>(origin->isolatedCopy(), name.isolatedCopy()));
scheduleForNotification();
}
static bool notificationScheduled = false;
void DatabaseTracker::scheduleForNotification()
{
ASSERT(!notificationMutex().tryLock());
if (!notificationScheduled) {
callOnMainThread(DatabaseTracker::notifyDatabasesChanged, 0);
notificationScheduled = true;
}
}
void DatabaseTracker::notifyDatabasesChanged(void*)
{
DatabaseTracker& theTracker(tracker());
NotificationQueue notifications;
{
MutexLocker locker(notificationMutex());
notifications.swap(notificationQueue());
notificationScheduled = false;
}
if (!theTracker.m_client)
return;
for (unsigned i = 0; i < notifications.size(); ++i)
theTracker.m_client->dispatchDidModifyDatabase(notifications[i].first.get(), notifications[i].second);
}
} #endif