void StorageTracker::syncImportOriginIdentifiers()
{
ASSERT(m_isActive);
ASSERT(!isMainThread());
{
MutexLocker lockDatabase(m_databaseGuard);
// Don't force creation of StorageTracker's db just because a tracker
// was initialized. It will be created if local storage dbs are found
// by syncFileSystemAndTrackerDatabse() or the next time a local storage
// db is created by StorageAreaSync.
openTrackerDatabase(false);
if (m_database.isOpen()) {
SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Failed to prepare statement.");
return;
}
int result;
{
MutexLocker lockOrigins(m_originSetGuard);
while ((result = statement.step()) == SQLResultRow)
m_originSet.add(statement.getColumnText(0).threadsafeCopy());
}
if (result != SQLResultDone) {
LOG_ERROR("Failed to read in all origins from the database.");
return;
}
}
}
syncFileSystemAndTrackerDatabase();
{
MutexLocker lockClient(m_clientGuard);
if (m_client) {
MutexLocker lockOrigins(m_originSetGuard);
OriginSet::const_iterator end = m_originSet.end();
for (OriginSet::const_iterator it = m_originSet.begin(); it != end; ++it)
m_client->dispatchDidModifyOrigin(*it);
}
}
}
void StorageTracker::deleteOrigin(SecurityOrigin* origin)
{
ASSERT(m_isActive);
ASSERT(isMainThread());
ASSERT(m_thread);
if (!m_isActive)
return;
// Before deleting database, we need to clear in-memory local storage data
// in StorageArea, and to close the StorageArea db. It's possible for an
// item to be added immediately after closing the db and cause StorageAreaSync
// to reopen the db before the db is deleted by a StorageTracker thread.
// In this case, reopening the db in StorageAreaSync will cancel a pending
// StorageTracker db deletion.
PageGroup::clearLocalStorageForOrigin(origin);
String originId = origin->databaseIdentifier();
{
MutexLocker lockOrigins(m_originSetGuard);
willDeleteOrigin(originId);
m_originSet.remove(originId);
}
m_thread->scheduleTask(LocalStorageTask::createDeleteOrigin(originId));
}
void StorageTracker::syncSetOriginDetails(const String& originIdentifier, const String& databaseFile)
{
ASSERT(!isMainThread());
MutexLocker lockDatabase(m_databaseGuard);
openTrackerDatabase(true);
if (!m_database.isOpen())
return;
SQLiteStatement statement(m_database, "INSERT INTO Origins VALUES (?, ?)");
if (statement.prepare() != SQLResultOk) {
LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.ascii().data());
return;
}
statement.bindText(1, originIdentifier);
statement.bindText(2, databaseFile);
if (statement.step() != SQLResultDone)
LOG_ERROR("Unable to establish origin '%s' in the tracker", originIdentifier.ascii().data());
{
MutexLocker lockOrigins(m_originSetGuard);
if (!m_originSet.contains(originIdentifier))
m_originSet.add(originIdentifier);
}
{
MutexLocker lockClient(m_clientGuard);
if (m_client)
m_client->dispatchDidModifyOrigin(originIdentifier);
}
}
void StorageTracker::syncImportOriginIdentifiers()
{
ASSERT(m_isActive);
ASSERT(!isMainThread());
{
LockHolder locker(m_databaseMutex);
// Don't force creation of StorageTracker's db just because a tracker
// was initialized. It will be created if local storage dbs are found
// by syncFileSystemAndTrackerDatabse() or the next time a local storage
// db is created by StorageAreaSync.
openTrackerDatabase(false);
if (m_database.isOpen()) {
SQLiteTransactionInProgressAutoCounter transactionCounter;
SQLiteStatement statement(m_database, "SELECT origin FROM Origins");
if (statement.prepare() != SQLITE_OK) {
LOG_ERROR("Failed to prepare statement.");
return;
}
int result;
{
LockHolder lockOrigins(m_originSetMutex);
while ((result = statement.step()) == SQLITE_ROW)
m_originSet.add(statement.getColumnText(0).isolatedCopy());
}
if (result != SQLITE_DONE) {
LOG_ERROR("Failed to read in all origins from the database.");
return;
}
}
}
syncFileSystemAndTrackerDatabase();
{
LockHolder locker(m_clientMutex);
if (m_client) {
LockHolder locker(m_originSetMutex);
OriginSet::const_iterator end = m_originSet.end();
for (OriginSet::const_iterator it = m_originSet.begin(); it != end; ++it)
m_client->dispatchDidModifyOrigin(*it);
}
}
callOnMainThread([this] {
finishedImportingOriginIdentifiers();
});
}
void StorageTracker::cancelDeletingOrigin(const String& originIdentifier)
{
if (!m_isActive)
return;
MutexLocker lockDatabase(m_databaseGuard);
MutexLocker lockOrigins(m_originSetGuard);
if (!m_originsBeingDeleted.isEmpty())
m_originsBeingDeleted.remove(originIdentifier);
}
void StorageTracker::origins(Vector<RefPtr<SecurityOrigin> >& result)
{
ASSERT(m_isActive);
if (!m_isActive)
return;
MutexLocker lockOrigins(m_originSetGuard);
OriginSet::const_iterator end = m_originSet.end();
for (OriginSet::const_iterator it = m_originSet.begin(); it != end; ++it)
result.append(SecurityOrigin::createFromDatabaseIdentifier(*it));
}
void StorageTracker::deleteAllOrigins()
{
ASSERT(m_isActive);
ASSERT(isMainThread());
ASSERT(m_thread);
if (!m_isActive)
return;
{
MutexLocker lockOrigins(m_originSetGuard);
willDeleteAllOrigins();
m_originSet.clear();
}
PageGroup::clearLocalStorageForAllOrigins();
m_thread->scheduleTask(LocalStorageTask::createDeleteAllOrigins());
}
void StorageTracker::setOriginDetails(const String& originIdentifier, const String& databaseFile)
{
if (!m_isActive)
return;
{
MutexLocker lockOrigins(m_originSetGuard);
if (m_originSet.contains(originIdentifier))
return;
m_originSet.add(originIdentifier);
}
OwnPtr<LocalStorageTask> task = LocalStorageTask::createSetOriginDetails(originIdentifier.threadsafeCopy(), databaseFile);
if (isMainThread()) {
ASSERT(m_thread);
m_thread->scheduleTask(task.release());
} else
callOnMainThread(scheduleTask, reinterpret_cast<void*>(task.leakPtr()));
}
bool StorageTracker::canDeleteOrigin(const String& originIdentifier)
{
ASSERT(!m_databaseGuard.tryLock());
MutexLocker lockOrigins(m_originSetGuard);
return m_originsBeingDeleted.contains(originIdentifier);
}
