void UniqueIDBDatabase::changeDatabaseVersion(const IDBTransactionIdentifier& identifier, uint64_t newVersion, std::function<void(bool)> successCallback)
{
ASSERT(isMainThread());
if (!m_acceptingNewRequests) {
successCallback(false);
return;
}
uint64_t oldVersion = m_metadata->version;
m_metadata->version = newVersion;
RefPtr<AsyncRequest> request = AsyncRequestImpl<bool>::create([this, oldVersion, successCallback](bool success) {
if (!success)
m_metadata->version = oldVersion;
successCallback(success);
}, [this, oldVersion, successCallback]() {
m_metadata->version = oldVersion;
successCallback(false);
});
uint64_t requestID = request->requestID();
m_pendingDatabaseTasks.add(requestID, request.release());
postDatabaseTask(createAsyncTask(*this, &UniqueIDBDatabase::changeDatabaseVersionInBackingStore, requestID, identifier, newVersion));
}
void UniqueIDBDatabase::getOrEstablishIDBDatabaseMetadata(std::function<void(bool, const IDBDatabaseMetadata&)> completionCallback)
{
ASSERT(isMainThread());
if (!m_acceptingNewRequests) {
completionCallback(false, IDBDatabaseMetadata());
return;
}
// If we've already retrieved metadata from the backing store, return it now.
if (m_didGetMetadataFromBackingStore) {
if (m_metadata)
completionCallback(true, *m_metadata);
else
completionCallback(false, IDBDatabaseMetadata());
return;
}
// If this is the first unanswered metadata request, post a task to open the backing store and get metadata.
if (m_pendingMetadataRequests.isEmpty())
postDatabaseTask(createAsyncTask(*this, &UniqueIDBDatabase::openBackingStoreAndReadMetadata, m_identifier, absoluteDatabaseDirectory()));
// Then remember this metadata request to be answered later.
RefPtr<AsyncRequest> request = AsyncRequestImpl<>::create([completionCallback, this]() {
completionCallback(!!m_metadata, m_metadata ? *m_metadata : IDBDatabaseMetadata());
}, [completionCallback]() {
// The boolean flag to the completion callback represents whether the
// attempt to get/establish metadata succeeded or failed.
// Since we're aborting the attempt, it failed, so we always pass in false.
completionCallback(false, IDBDatabaseMetadata());
});
m_pendingMetadataRequests.append(request.release());
}
void UniqueIDBDatabase::changeDatabaseVersionInBackingStore(uint64_t requestID, const IDBTransactionIdentifier& identifier, uint64_t newVersion)
{
ASSERT(!isMainThread());
ASSERT(m_backingStore);
bool success = m_backingStore->changeDatabaseVersion(identifier, newVersion);
postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didChangeDatabaseVersion, requestID, success));
}
void UniqueIDBDatabase::rollbackBackingStoreTransaction(const IDBTransactionIdentifier& identifier)
{
ASSERT(!isMainThread());
ASSERT(m_backingStore);
bool success = m_backingStore->rollbackTransaction(identifier);
postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, identifier, success));
}
void UniqueIDBDatabase::openBackingStoreTransaction(const IDBTransactionIdentifier& identifier, const Vector<int64_t>& objectStoreIDs, WebCore::IndexedDB::TransactionMode mode)
{
ASSERT(!isMainThread());
ASSERT(m_backingStore);
bool success = m_backingStore->establishTransaction(identifier, objectStoreIDs, mode);
postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didCompleteTransactionOperation, identifier, success));
}
void UniqueIDBDatabase::openBackingStoreAndReadMetadata(const UniqueIDBDatabaseIdentifier& identifier, const String& databaseDirectory)
{
ASSERT(!isMainThread());
ASSERT(!m_backingStore);
if (m_inMemory) {
LOG_ERROR("Support for in-memory databases not yet implemented");
return;
}
m_backingStore = UniqueIDBDatabaseBackingStoreSQLite::create(identifier, databaseDirectory);
std::unique_ptr<IDBDatabaseMetadata> metadata = m_backingStore->getOrEstablishMetadata();
postMainThreadTask(createAsyncTask(*this, &UniqueIDBDatabase::didOpenBackingStoreAndReadMetadata, metadata ? *metadata : IDBDatabaseMetadata(), !!metadata));
}
void DatabaseProcess::ensureIndexedDatabaseRelativePathExists(const String& relativePath)
{
postDatabaseTask(createAsyncTask(*this, &DatabaseProcess::ensurePathExists, absoluteIndexedDatabasePathFromDatabaseRelativePath(relativePath)));
}
void UniqueIDBDatabase::rollbackTransaction(const IDBTransactionIdentifier& identifier, std::function<void(bool)> successCallback)
{
postTransactionOperation(identifier, createAsyncTask(*this, &UniqueIDBDatabase::rollbackBackingStoreTransaction, identifier), successCallback);
}
void UniqueIDBDatabase::openTransaction(const IDBTransactionIdentifier& identifier, const Vector<int64_t>& objectStoreIDs, WebCore::IndexedDB::TransactionMode mode, std::function<void(bool)> successCallback)
{
postTransactionOperation(identifier, createAsyncTask(*this, &UniqueIDBDatabase::openBackingStoreTransaction, identifier, objectStoreIDs, mode), successCallback);
}