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 WebIDBCallbacksImpl::onSuccess(WebIDBDatabase* backend, const WebIDBMetadata& metadata)
{
InspectorInstrumentation::AsyncTask asyncTask(m_request->getExecutionContext(), this);
m_request->onSuccess(wrapUnique(backend), IDBDatabaseMetadata(metadata));
}
void WebIDBCallbacksImpl::onUpgradeNeeded(long long oldVersion, WebIDBDatabase* database, const WebIDBMetadata& metadata, unsigned short dataLoss, WebString dataLossMessage)
{
InspectorInstrumentation::AsyncTask asyncTask(m_request->getExecutionContext(), this);
m_request->onUpgradeNeeded(oldVersion, wrapUnique(database), IDBDatabaseMetadata(metadata), static_cast<WebIDBDataLoss>(dataLoss), dataLossMessage);
}
void WebIDBCallbacksImpl::onSuccess(WebIDBDatabase* backend, const WebIDBMetadata& metadata)
{
InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncCallbackStarting(m_request->executionContext(), m_asyncOperationId);
m_request->onSuccess(adoptPtr(backend), IDBDatabaseMetadata(metadata));
InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
}
void WebIDBCallbacksImpl::onUpgradeNeeded(long long oldVersion, WebIDBDatabase* database, const WebIDBMetadata& metadata, unsigned short dataLoss, WebString dataLossMessage)
{
InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncCallbackStarting(m_request->executionContext(), m_asyncOperationId);
m_request->onUpgradeNeeded(oldVersion, adoptPtr(database), IDBDatabaseMetadata(metadata), static_cast<WebIDBDataLoss>(dataLoss), dataLossMessage);
InspectorInstrumentation::traceAsyncCallbackCompleted(cookie);
}
IDBTransaction* IDBTransaction::create(ScriptState* scriptState, int64_t id, const HashSet<String>& objectStoreNames, WebIDBTransactionMode mode, IDBDatabase* db)
{
IDBOpenDBRequest* openDBRequest = nullptr;
IDBTransaction* transaction = new IDBTransaction(scriptState, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata());
transaction->suspendIfNeeded();
return transaction;
}
Ref<LegacyTransaction> LegacyTransaction::create(ScriptExecutionContext* context, int64_t id, const Vector<String>& objectStoreNames, IndexedDB::TransactionMode mode, LegacyDatabase* db)
{
LegacyOpenDBRequest* openDBRequest = nullptr;
Ref<LegacyTransaction> transaction(adoptRef(*new LegacyTransaction(context, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata())));
transaction->suspendIfNeeded();
return transaction;
}
PassRefPtr<IDBTransaction> IDBTransaction::create(ExecutionContext* context, int64_t id, const Vector<String>& objectStoreNames, WebIDBDatabase::TransactionMode mode, IDBDatabase* db)
{
IDBOpenDBRequest* openDBRequest = 0;
RefPtr<IDBTransaction> transaction(adoptRef(new IDBTransaction(context, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata())));
transaction->suspendIfNeeded();
return transaction.release();
}
IDBTransaction* IDBTransaction::create(ExecutionContext* context, int64_t id, const Vector<String>& objectStoreNames, WebIDBDatabase::TransactionMode mode, IDBDatabase* db)
{
IDBOpenDBRequest* openDBRequest = 0;
IDBTransaction* transaction = adoptRefCountedGarbageCollected(new IDBTransaction(context, id, objectStoreNames, mode, db, openDBRequest, IDBDatabaseMetadata()));
transaction->suspendIfNeeded();
return transaction;
}
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));
}
