RefPtr<IDBTransaction> LegacyDatabase::transaction(ScriptExecutionContext* context, const Vector<String>& scope, const String& modeString, ExceptionCode& ec)
{
LOG(StorageAPI, "LegacyDatabase::transaction");
if (!scope.size()) {
ec = IDBDatabaseException::InvalidAccessError;
return 0;
}
IndexedDB::TransactionMode mode = IDBTransaction::stringToMode(modeString, ec);
if (ec)
return 0;
if (m_versionChangeTransaction || m_closePending) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
Vector<int64_t> objectStoreIds;
for (auto& name : scope) {
int64_t objectStoreId = findObjectStoreId(name);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
ec = IDBDatabaseException::NotFoundError;
return 0;
}
objectStoreIds.append(objectStoreId);
}
int64_t transactionId = nextTransactionId();
m_backend->createTransaction(transactionId, m_databaseCallbacks, objectStoreIds, mode);
RefPtr<LegacyTransaction> transaction = LegacyTransaction::create(context, transactionId, scope, mode, this);
return transaction.release();
}
PassRefPtr<IDBTransaction> IDBDatabase::transaction(ScriptExecutionContext* context, const Vector<String>& scope, const String& modeString, ExceptionCode& ec)
{
IDB_TRACE("IDBDatabase::transaction");
HistogramSupport::histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBTransactionCall, IDBMethodsMax);
if (!scope.size()) {
ec = IDBDatabaseException::InvalidAccessError;
return 0;
}
IndexedDB::TransactionMode mode = IDBTransaction::stringToMode(modeString, ec);
if (ec)
return 0;
if (m_versionChangeTransaction || m_closePending) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
Vector<int64_t> objectStoreIds;
for (size_t i = 0; i < scope.size(); ++i) {
int64_t objectStoreId = findObjectStoreId(scope[i]);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
ec = IDBDatabaseException::NotFoundError;
return 0;
}
objectStoreIds.append(objectStoreId);
}
int64_t transactionId = nextTransactionId();
m_backend->createTransaction(transactionId, m_databaseCallbacks, objectStoreIds, mode);
RefPtr<IDBTransaction> transaction = IDBTransaction::create(context, transactionId, scope, mode, this);
return transaction.release();
}
void IDBDatabase::deleteObjectStore(const String& name, ExceptionState& exceptionState)
{
IDB_TRACE("IDBDatabase::deleteObjectStore");
Platform::current()->histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBDeleteObjectStoreCall, IDBMethodsMax);
if (!m_versionChangeTransaction) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
return;
}
if (m_versionChangeTransaction->isFinished() || m_versionChangeTransaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return;
}
if (!m_versionChangeTransaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return;
}
int64_t objectStoreId = findObjectStoreId(name);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
exceptionState.throwDOMException(NotFoundError, "The specified object store was not found.");
return;
}
if (!m_backend) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return;
}
m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);
m_versionChangeTransaction->objectStoreDeleted(name);
m_metadata.objectStores.remove(objectStoreId);
}
PassRefPtr<IDBTransaction> IDBDatabase::transaction(ScriptExecutionContext* context, const Vector<String>& scope, const String& modeString, ExceptionCode& ec)
{
if (!scope.size()) {
ec = IDBDatabaseException::IDB_INVALID_ACCESS_ERR;
return 0;
}
IDBTransaction::Mode mode = IDBTransaction::stringToMode(modeString, context, ec);
if (ec)
return 0;
if (m_versionChangeTransaction || m_closePending) {
ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
return 0;
}
Vector<int64_t> objectStoreIds;
for (size_t i = 0; i < scope.size(); ++i) {
int64_t objectStoreId = findObjectStoreId(scope[i]);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
ec = IDBDatabaseException::IDB_NOT_FOUND_ERR;
return 0;
}
objectStoreIds.append(objectStoreId);
}
// We need to create a new transaction synchronously. Locks are acquired asynchronously. Operations
// can be queued against the transaction at any point. They will start executing as soon as the
// appropriate locks have been acquired.
// Also note that each backend object corresponds to exactly one IDBTransaction object.
int64_t transactionId = nextTransactionId();
RefPtr<IDBTransactionBackendInterface> transactionBackend = m_backend->createTransaction(transactionId, objectStoreIds, mode);
if (!transactionBackend) {
ASSERT(ec);
return 0;
}
RefPtr<IDBTransaction> transaction = IDBTransaction::create(context, transactionId, transactionBackend, scope, mode, this);
transactionBackend->setCallbacks(transaction.get());
return transaction.release();
}
void LegacyDatabase::deleteObjectStore(const String& name, ExceptionCode& ec)
{
LOG(StorageAPI, "LegacyDatabase::deleteObjectStore");
if (!m_versionChangeTransaction) {
ec = IDBDatabaseException::InvalidStateError;
return;
}
if (!m_versionChangeTransaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return;
}
int64_t objectStoreId = findObjectStoreId(name);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
ec = IDBDatabaseException::NotFoundError;
return;
}
m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);
m_versionChangeTransaction->objectStoreDeleted(name);
m_metadata.objectStores.remove(objectStoreId);
}
PassRefPtr<IDBTransaction> IDBDatabase::transaction(ExecutionContext* context, const Vector<String>& scope, const String& modeString, ExceptionState& exceptionState)
{
IDB_TRACE("IDBDatabase::transaction");
blink::Platform::current()->histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBTransactionCall, IDBMethodsMax);
if (!scope.size()) {
exceptionState.throwDOMException(InvalidAccessError, "The storeNames parameter was empty.");
return nullptr;
}
blink::WebIDBDatabase::TransactionMode mode = IDBTransaction::stringToMode(modeString, exceptionState);
if (exceptionState.hadException())
return nullptr;
if (m_versionChangeTransaction) {
exceptionState.throwDOMException(InvalidStateError, "A version change transaction is running.");
return nullptr;
}
if (m_closePending) {
exceptionState.throwDOMException(InvalidStateError, "The database connection is closing.");
return nullptr;
}
Vector<int64_t> objectStoreIds;
for (size_t i = 0; i < scope.size(); ++i) {
int64_t objectStoreId = findObjectStoreId(scope[i]);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
exceptionState.throwDOMException(NotFoundError, "One of the specified object stores was not found.");
return nullptr;
}
objectStoreIds.append(objectStoreId);
}
int64_t transactionId = nextTransactionId();
m_backend->createTransaction(transactionId, WebIDBDatabaseCallbacksImpl::create(m_databaseCallbacks).leakPtr(), objectStoreIds, mode);
RefPtr<IDBTransaction> transaction = IDBTransaction::create(context, transactionId, scope, mode, this);
return transaction.release();
}
void IDBDatabase::deleteObjectStore(const String& name,
ExceptionState& exceptionState) {
IDB_TRACE("IDBDatabase::deleteObjectStore");
recordApiCallsHistogram(IDBDeleteObjectStoreCall);
if (!m_versionChangeTransaction) {
exceptionState.throwDOMException(
InvalidStateError,
IDBDatabase::notVersionChangeTransactionErrorMessage);
return;
}
if (m_versionChangeTransaction->isFinished() ||
m_versionChangeTransaction->isFinishing()) {
exceptionState.throwDOMException(
TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return;
}
if (!m_versionChangeTransaction->isActive()) {
exceptionState.throwDOMException(
TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return;
}
int64_t objectStoreId = findObjectStoreId(name);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
exceptionState.throwDOMException(
NotFoundError, "The specified object store was not found.");
return;
}
if (!m_backend) {
exceptionState.throwDOMException(InvalidStateError,
IDBDatabase::databaseClosedErrorMessage);
return;
}
m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);
m_versionChangeTransaction->objectStoreDeleted(objectStoreId, name);
m_metadata.objectStores.remove(objectStoreId);
}
void IDBDatabase::deleteObjectStore(const String& name, ExceptionCode& ec)
{
IDB_TRACE("IDBDatabase::deleteObjectStore");
HistogramSupport::histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBDeleteObjectStoreCall, IDBMethodsMax);
if (!m_versionChangeTransaction) {
ec = IDBDatabaseException::InvalidStateError;
return;
}
if (!m_versionChangeTransaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return;
}
int64_t objectStoreId = findObjectStoreId(name);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
ec = IDBDatabaseException::NotFoundError;
return;
}
m_backend->deleteObjectStore(m_versionChangeTransaction->id(), objectStoreId);
m_versionChangeTransaction->objectStoreDeleted(name);
m_metadata.objectStores.remove(objectStoreId);
}
void IDBDatabase::deleteObjectStore(const String& name, ExceptionCode& ec)
{
if (!m_versionChangeTransaction) {
ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
return;
}
if (!m_versionChangeTransaction->isActive()) {
ec = IDBDatabaseException::TRANSACTION_INACTIVE_ERR;
return;
}
int64_t objectStoreId = findObjectStoreId(name);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
ec = IDBDatabaseException::IDB_NOT_FOUND_ERR;
return;
}
m_backend->deleteObjectStore(objectStoreId, m_versionChangeTransaction->backend(), ec);
if (!ec) {
m_versionChangeTransaction->objectStoreDeleted(name);
m_metadata.objectStores.remove(objectStoreId);
}
}
IDBTransaction* IDBDatabase::transaction(ScriptState* scriptState, const StringOrStringSequenceOrDOMStringList& storeNames, const String& modeString, ExceptionState& exceptionState)
{
IDB_TRACE("IDBDatabase::transaction");
Platform::current()->histogramEnumeration("WebCore.IndexedDB.FrontEndAPICalls", IDBTransactionCall, IDBMethodsMax);
HashSet<String> scope;
if (storeNames.isString()) {
scope.add(storeNames.getAsString());
} else if (storeNames.isStringSequence()) {
for (const String& name : storeNames.getAsStringSequence())
scope.add(name);
} else if (storeNames.isDOMStringList()) {
const Vector<String>& list = *storeNames.getAsDOMStringList();
for (const String& name : list)
scope.add(name);
} else {
ASSERT_NOT_REACHED();
}
if (scope.isEmpty()) {
exceptionState.throwDOMException(InvalidAccessError, "The storeNames parameter was empty.");
return nullptr;
}
WebIDBTransactionMode mode = IDBTransaction::stringToMode(modeString);
if (mode != WebIDBTransactionModeReadOnly && mode != WebIDBTransactionModeReadWrite) {
exceptionState.throwTypeError("The mode provided ('" + modeString + "') is not one of 'readonly' or 'readwrite'.");
return nullptr;
}
if (exceptionState.hadException())
return nullptr;
if (m_versionChangeTransaction) {
exceptionState.throwDOMException(InvalidStateError, "A version change transaction is running.");
return nullptr;
}
if (m_closePending) {
exceptionState.throwDOMException(InvalidStateError, "The database connection is closing.");
return nullptr;
}
Vector<int64_t> objectStoreIds;
for (const String& name : scope) {
int64_t objectStoreId = findObjectStoreId(name);
if (objectStoreId == IDBObjectStoreMetadata::InvalidId) {
exceptionState.throwDOMException(NotFoundError, "One of the specified object stores was not found.");
return nullptr;
}
objectStoreIds.append(objectStoreId);
}
if (!m_backend) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
int64_t transactionId = nextTransactionId();
m_backend->createTransaction(transactionId, WebIDBDatabaseCallbacksImpl::create(m_databaseCallbacks).leakPtr(), objectStoreIds, mode);
return IDBTransaction::create(scriptState, transactionId, scope, mode, this);
}