IDBRequest* IDBObjectStore::count(ScriptState* scriptState, const ScriptValue& range, ExceptionState& exceptionState)
{
IDB_TRACE("IDBObjectStore::count");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
return 0;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return 0;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return 0;
}
IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->executionContext(), range, exceptionState);
if (exceptionState.hadException())
return 0;
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return 0;
}
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
backendDB()->count(m_transaction->id(), id(), IDBIndexMetadata::InvalidId, keyRange, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
PassRefPtrWillBeRawPtr<IDBRequest> IDBIndex::count(ExecutionContext* context, const ScriptValue& range, ExceptionState& exceptionState)
{
IDB_TRACE("IDBIndex::count");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return nullptr;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return nullptr;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return nullptr;
}
RefPtrWillBeRawPtr<IDBKeyRange> keyRange = IDBKeyRange::fromScriptValue(context, range, exceptionState);
if (exceptionState.hadException())
return nullptr;
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
RefPtrWillBeRawPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
backendDB()->count(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange.release(), WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
IDBRequest* IDBIndex::openKeyCursor(ScriptState* scriptState, const ScriptValue& range, const String& directionString, ExceptionState& exceptionState)
{
IDB_TRACE("IDBIndex::openKeyCursor");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return 0;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return 0;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return 0;
}
blink::WebIDBCursorDirection direction = IDBCursor::stringToDirection(directionString, exceptionState);
if (exceptionState.hadException())
return 0;
IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->executionContext(), range, exceptionState);
if (exceptionState.hadException())
return 0;
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return 0;
}
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
request->setCursorDetails(IndexedDB::CursorKeyOnly, direction);
backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, direction, true, blink::WebIDBTaskTypeNormal, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
IDBIndex* IDBObjectStore::createIndex(ScriptState* scriptState, const String& name, const IDBKeyPath& keyPath, const IDBIndexParameters& options, ExceptionState& exceptionState)
{
IDB_TRACE("IDBObjectStore::createIndex");
if (!m_transaction->isVersionChange()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
return 0;
}
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
return 0;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return 0;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return 0;
}
if (!keyPath.isValid()) {
exceptionState.throwDOMException(SyntaxError, "The keyPath argument contains an invalid key path.");
return 0;
}
if (containsIndex(name)) {
exceptionState.throwDOMException(ConstraintError, "An index with the specified name already exists.");
return 0;
}
if (keyPath.type() == IDBKeyPath::ArrayType && options.multiEntry()) {
exceptionState.throwDOMException(InvalidAccessError, "The keyPath argument was an array and the multiEntry option is true.");
return 0;
}
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return 0;
}
int64_t indexId = m_metadata.maxIndexId + 1;
backendDB()->createIndex(m_transaction->id(), id(), indexId, name, keyPath, options.unique(), options.multiEntry());
++m_metadata.maxIndexId;
IDBIndexMetadata metadata(name, indexId, keyPath, options.unique(), options.multiEntry());
IDBIndex* index = IDBIndex::create(metadata, this, m_transaction.get());
m_indexMap.set(name, index);
m_metadata.indexes.set(indexId, metadata);
m_transaction->db()->indexCreated(id(), metadata);
ASSERT(!exceptionState.hadException());
if (exceptionState.hadException())
return 0;
IDBRequest* indexRequest = openCursor(scriptState, nullptr, WebIDBCursorDirectionNext, WebIDBTaskTypePreemptive);
indexRequest->preventPropagation();
// This is kept alive by being the success handler of the request, which is in turn kept alive by the owning transaction.
RefPtr<IndexPopulator> indexPopulator = IndexPopulator::create(scriptState, transaction()->db(), m_transaction->id(), id(), metadata);
indexRequest->setOnsuccess(indexPopulator);
return index;
}
IDBRequest* IDBObjectStore::getAllKeys(ScriptState* scriptState, const ScriptValue& keyRange, unsigned long maxCount, ExceptionState& exceptionState)
{
IDB_TRACE("IDBObjectStore::getAll");
if (!maxCount)
maxCount = std::numeric_limits<uint32_t>::max();
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
return nullptr;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return nullptr;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return nullptr;
}
IDBKeyRange* range = IDBKeyRange::fromScriptValue(scriptState->executionContext(), keyRange, exceptionState);
if (exceptionState.hadException())
return nullptr;
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
backendDB()->getAll(m_transaction->id(), id(), IDBIndexMetadata::InvalidId, range, maxCount, true, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
IDBRequest* IDBIndex::getInternal(ScriptState* scriptState, const ScriptValue& key, ExceptionState& exceptionState, bool keyOnly)
{
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return 0;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return 0;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return 0;
}
IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->executionContext(), key, exceptionState);
if (exceptionState.hadException())
return 0;
if (!keyRange) {
exceptionState.throwDOMException(DataError, IDBDatabase::noKeyOrKeyRangeErrorMessage);
return 0;
}
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return 0;
}
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
backendDB()->get(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, keyOnly, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
IDBRequest* IDBObjectStore::clear(ScriptState* scriptState, ExceptionState& exceptionState)
{
IDB_TRACE("IDBObjectStore::clear");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
return nullptr;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return nullptr;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return nullptr;
}
if (m_transaction->isReadOnly()) {
exceptionState.throwDOMException(ReadOnlyError, IDBDatabase::transactionReadOnlyErrorMessage);
return nullptr;
}
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
backendDB()->clear(m_transaction->id(), id(), WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
PassRefPtrWillBeRawPtr<IDBRequest> IDBIndex::openKeyCursor(ExecutionContext* context, const ScriptValue& range, const String& directionString, ExceptionState& exceptionState)
{
IDB_TRACE("IDBIndex::openKeyCursor");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return nullptr;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return nullptr;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return nullptr;
}
WebIDBCursor::Direction direction = IDBCursor::stringToDirection(directionString, exceptionState);
if (exceptionState.hadException())
return nullptr;
RefPtrWillBeRawPtr<IDBKeyRange> keyRange = IDBKeyRange::fromScriptValue(context, range, exceptionState);
if (exceptionState.hadException())
return nullptr;
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
RefPtrWillBeRawPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
request->setCursorDetails(IndexedDB::CursorKeyOnly, direction);
backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange.release(), direction, true, WebIDBDatabase::NormalTask, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
PassRefPtr<IDBIndex> IDBObjectStore::createIndex(ScriptExecutionContext* context, const String& name, const IDBKeyPath& keyPath, bool unique, bool multiEntry, ExceptionCode& ec)
{
IDB_TRACE("IDBObjectStore::createIndex");
if (!m_transaction->isVersionChange() || isDeleted()) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
if (!keyPath.isValid()) {
ec = IDBDatabaseException::SyntaxError;
return 0;
}
if (name.isNull()) {
ec = TypeError;
return 0;
}
if (containsIndex(name)) {
ec = IDBDatabaseException::ConstraintError;
return 0;
}
if (keyPath.type() == IDBKeyPath::ArrayType && multiEntry) {
ec = IDBDatabaseException::InvalidAccessError;
return 0;
}
int64_t indexId = m_metadata.maxIndexId + 1;
backendDB()->createIndex(m_transaction->id(), id(), indexId, name, keyPath, unique, multiEntry);
++m_metadata.maxIndexId;
IDBIndexMetadata metadata(name, indexId, keyPath, unique, multiEntry);
RefPtr<IDBIndex> index = IDBIndex::create(metadata, this, m_transaction.get());
m_indexMap.set(name, index);
m_metadata.indexes.set(indexId, metadata);
m_transaction->db()->indexCreated(id(), metadata);
ASSERT(!ec);
if (ec)
return 0;
RefPtr<IDBRequest> indexRequest = openCursor(context, static_cast<IDBKeyRange*>(0), IDBCursor::directionNext(), IDBDatabaseBackendInterface::PreemptiveTask, ec);
ASSERT(!ec);
if (ec)
return 0;
indexRequest->preventPropagation();
// This is kept alive by being the success handler of the request, which is in turn kept alive by the owning transaction.
RefPtr<IndexPopulator> indexPopulator = IndexPopulator::create(backendDB(), m_transaction->id(), id(), metadata);
indexRequest->setOnsuccess(indexPopulator);
return index.release();
}
void IDBTransaction::setActive(bool active)
{
ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to setActive(%s)", active ? "true" : "false");
if (m_state == Finishing)
return;
ASSERT(active != (m_state == Active));
m_state = active ? Active : Inactive;
if (!active && m_requestList.isEmpty() && backendDB())
backendDB()->commit(m_id);
}
void IDBTransaction::setActive(bool active) {
DCHECK_NE(m_state, Finished) << "A finished transaction tried to setActive("
<< (active ? "true" : "false") << ")";
if (m_state == Finishing)
return;
DCHECK_NE(active, (m_state == Active));
m_state = active ? Active : Inactive;
if (!active && m_requestList.isEmpty() && backendDB())
backendDB()->commit(m_id);
}
void IDBObjectStore::deleteIndex(const String& name, ExceptionCode& ec)
{
LOG(StorageAPI, "IDBObjectStore::deleteIndex");
if (!m_transaction->isVersionChange() || m_deleted) {
ec = IDBDatabaseException::InvalidStateError;
return;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return;
}
int64_t indexId = findIndexId(name);
if (indexId == IDBIndexMetadata::InvalidId) {
ec = IDBDatabaseException::NotFoundError;
return;
}
backendDB()->deleteIndex(m_transaction->id(), id(), indexId);
m_metadata.indexes.remove(indexId);
IDBIndexMap::iterator it = m_indexMap.find(name);
if (it != m_indexMap.end()) {
it->value->markDeleted();
m_indexMap.remove(name);
}
}
PassRefPtr<IDBRequest> IDBIndex::getKey(ScriptExecutionContext* context, const ScriptValue& key, ExceptionState& es)
{
IDB_TRACE("IDBIndex::getKey");
if (isDeleted()) {
es.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return 0;
}
if (m_transaction->isFinished()) {
es.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return 0;
}
if (!m_transaction->isActive()) {
es.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return 0;
}
RefPtr<IDBKeyRange> keyRange = IDBKeyRange::fromScriptValue(context, key, es);
if (es.hadException())
return 0;
if (!keyRange) {
es.throwDOMException(DataError, IDBDatabase::noKeyOrKeyRangeErrorMessage);
return 0;
}
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
backendDB()->get(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, true, request);
return request;
}
PassRefPtr<IDBRequest> IDBIndex::openKeyCursor(ScriptExecutionContext* context, const ScriptValue& range, const String& directionString, ExceptionState& es)
{
IDB_TRACE("IDBIndex::openKeyCursor");
if (isDeleted()) {
es.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return 0;
}
if (m_transaction->isFinished()) {
es.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return 0;
}
if (!m_transaction->isActive()) {
es.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return 0;
}
IndexedDB::CursorDirection direction = IDBCursor::stringToDirection(directionString, es);
if (es.hadException())
return 0;
RefPtr<IDBKeyRange> keyRange = IDBKeyRange::fromScriptValue(context, range, es);
if (es.hadException())
return 0;
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
request->setCursorDetails(IndexedDB::CursorKeyOnly, direction);
backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, direction, true, IDBDatabaseBackendInterface::NormalTask, request);
return request;
}
PassRefPtr<IDBRequest> IDBIndex::openCursor(ExecutionContext* context, PassRefPtr<IDBKeyRange> keyRange, IndexedDB::CursorDirection direction)
{
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
request->setCursorDetails(IndexedDB::CursorKeyAndValue, direction);
backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, direction, false, WebIDBDatabase::NormalTask, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
IDBRequest* IDBIndex::openCursor(ScriptState* scriptState, const ScriptValue& range, const String& directionString, ExceptionState& exceptionState)
{
IDB_TRACE("IDBIndex::openCursor");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return nullptr;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return nullptr;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return nullptr;
}
WebIDBCursorDirection direction = IDBCursor::stringToDirection(directionString);
IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->getExecutionContext(), range, exceptionState);
if (exceptionState.hadException())
return nullptr;
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
return openCursor(scriptState, keyRange, direction);
}
PassRefPtrWillBeRawPtr<IDBRequest> IDBIndex::openCursor(ExecutionContext* context, const ScriptValue& range, const String& directionString, ExceptionState& exceptionState)
{
IDB_TRACE("IDBIndex::openCursor");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::indexDeletedErrorMessage);
return nullptr;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return nullptr;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return nullptr;
}
WebIDBCursor::Direction direction = IDBCursor::stringToDirection(directionString, exceptionState);
if (exceptionState.hadException())
return nullptr;
RefPtrWillBeRawPtr<IDBKeyRange> keyRange = IDBKeyRange::fromScriptValue(context, range, exceptionState);
if (exceptionState.hadException())
return nullptr;
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
return openCursor(context, keyRange.release(), direction);
}
IDBRequest* IDBIndex::openCursor(ScriptState* scriptState, IDBKeyRange* keyRange, WebIDBCursorDirection direction)
{
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
request->setCursorDetails(IndexedDB::CursorKeyAndValue, direction);
backendDB()->openCursor(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, direction, false, WebIDBTaskTypeNormal, WebIDBCallbacksImpl::create(request).release());
return request;
}
IDBRequest* IDBObjectStore::openCursor(ScriptState* scriptState, IDBKeyRange* range, WebIDBCursorDirection direction, WebIDBTaskType taskType)
{
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
request->setCursorDetails(IndexedDB::CursorKeyAndValue, direction);
backendDB()->openCursor(m_transaction->id(), id(), IDBIndexMetadata::InvalidId, range, direction, false, taskType, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
void IDBTransaction::abort(ExceptionState& exceptionState) {
if (m_state == Finishing || m_state == Finished) {
exceptionState.throwDOMException(
InvalidStateError, IDBDatabase::transactionFinishedErrorMessage);
return;
}
m_state = Finishing;
if (!getExecutionContext())
return;
abortOutstandingRequests();
revertDatabaseMetadata();
if (backendDB())
backendDB()->abort(m_id);
}
void IDBTransaction::abort(ExceptionState& exceptionState)
{
if (m_state == Finishing || m_state == Finished) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::transactionFinishedErrorMessage);
return;
}
m_state = Finishing;
if (m_contextStopped)
return;
while (!m_requestList.isEmpty()) {
IDBRequest* request = *m_requestList.begin();
m_requestList.remove(request);
request->abort();
}
if (backendDB())
backendDB()->abort(m_id);
}
void LegacyTransaction::setActive(bool active)
{
LOG(StorageAPI, "LegacyTransaction::setActive(%s) for transaction id %lli", active ? "true" : "false", static_cast<long long>(m_id));
ASSERT_WITH_MESSAGE(m_state != Finished, "A finished transaction tried to setActive(%s)", active ? "true" : "false");
if (m_state == Finishing)
return;
ASSERT(active != (m_state == Active));
m_state = active ? Active : Inactive;
if (!active && m_requestList.isEmpty())
backendDB()->commit(m_id);
}
void IDBObjectStore::deleteIndex(const String& name, ExceptionState& exceptionState)
{
IDB_TRACE("IDBObjectStore::deleteIndex");
if (!m_transaction->isVersionChange()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::notVersionChangeTransactionErrorMessage);
return;
}
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
return;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return;
}
int64_t indexId = findIndexId(name);
if (indexId == IDBIndexMetadata::InvalidId) {
exceptionState.throwDOMException(NotFoundError, IDBDatabase::noSuchIndexErrorMessage);
return;
}
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return;
}
backendDB()->deleteIndex(m_transaction->id(), id(), indexId);
m_metadata.indexes.remove(indexId);
m_transaction->db()->indexDeleted(id(), indexId);
IDBIndexMap::iterator it = m_indexMap.find(name);
if (it != m_indexMap.end()) {
it->value->markDeleted();
m_indexMap.remove(name);
}
}
IDBRequest* IDBObjectStore::deleteFunction(ScriptState* scriptState, const ScriptValue& key, ExceptionState& exceptionState)
{
IDB_TRACE("IDBObjectStore::delete");
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::objectStoreDeletedErrorMessage);
return nullptr;
}
if (m_transaction->isFinished() || m_transaction->isFinishing()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionFinishedErrorMessage);
return nullptr;
}
if (!m_transaction->isActive()) {
exceptionState.throwDOMException(TransactionInactiveError, IDBDatabase::transactionInactiveErrorMessage);
return nullptr;
}
if (m_transaction->isReadOnly()) {
exceptionState.throwDOMException(ReadOnlyError, IDBDatabase::transactionReadOnlyErrorMessage);
return nullptr;
}
IDBKeyRange* keyRange = IDBKeyRange::fromScriptValue(scriptState->executionContext(), key, exceptionState);
if (exceptionState.hadException())
return nullptr;
if (!keyRange) {
exceptionState.throwDOMException(DataError, IDBDatabase::noKeyOrKeyRangeErrorMessage);
return nullptr;
}
if (!backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
backendDB()->deleteRange(m_transaction->id(), id(), keyRange, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
PassRefPtr<IDBRequest> IDBIndex::count(ScriptExecutionContext* context, PassRefPtr<IDBKeyRange> keyRange, ExceptionCode& ec)
{
IDB_TRACE("IDBIndex::count");
if (m_deleted) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
backendDB()->count(m_transaction->id(), m_objectStore->id(), m_metadata.id, keyRange, request);
return request;
}
PassRefPtr<IDBRequest> IDBObjectStore::count(ScriptExecutionContext* context, PassRefPtr<IDBKeyRange> range, ExceptionCode& ec)
{
LOG(StorageAPI, "IDBObjectStore::count");
if (m_deleted) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
backendDB()->count(m_transaction->id(), id(), IDBIndexMetadata::InvalidId, range, request);
return request.release();
}
PassRefPtr<IDBIndex> IDBObjectStore::createIndex(ScriptExecutionContext* context, const String& name, const IDBKeyPath& keyPath, bool unique, bool multiEntry, ExceptionCode& ec)
{
LOG(StorageAPI, "IDBObjectStore::createIndex");
if (!m_transaction->isVersionChange() || m_deleted) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
if (!keyPath.isValid()) {
ec = IDBDatabaseException::SyntaxError;
return 0;
}
if (name.isNull()) {
ec = TypeError;
return 0;
}
if (containsIndex(name)) {
ec = IDBDatabaseException::ConstraintError;
return 0;
}
if (keyPath.type() == IDBKeyPath::ArrayType && multiEntry) {
ec = IDBDatabaseException::InvalidAccessError;
return 0;
}
int64_t indexId = m_metadata.maxIndexId + 1;
backendDB()->createIndex(m_transaction->id(), id(), indexId, name, keyPath, unique, multiEntry);
++m_metadata.maxIndexId;
IDBIndexMetadata metadata(name, indexId, keyPath, unique, multiEntry);
RefPtr<IDBIndex> index = IDBIndex::create(metadata, this, m_transaction.get());
m_indexMap.set(name, index);
m_metadata.indexes.set(indexId, metadata);
ASSERT(!ec);
if (ec)
return 0;
ASSERT_UNUSED(context, context);
return index.release();
}
void LegacyTransaction::abort(ExceptionCode& ec)
{
if (m_state == Finishing || m_state == Finished) {
ec = IDBDatabaseException::InvalidStateError;
return;
}
m_state = Finishing;
while (!m_requestList.isEmpty()) {
RefPtr<LegacyRequest> request = *m_requestList.begin();
m_requestList.remove(request);
request->abort();
}
RefPtr<LegacyTransaction> selfRef = this;
backendDB()->abort(m_id);
}
PassRefPtr<IDBRequest> IDBObjectStore::get(ScriptExecutionContext* context, PassRefPtr<IDBKeyRange> keyRange, ExceptionCode& ec)
{
IDB_TRACE("IDBObjectStore::get");
if (isDeleted()) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!keyRange) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
backendDB()->get(m_transaction->id(), id(), IDBIndexMetadata::InvalidId, keyRange, false, request);
return request.release();
}
PassRefPtr<IDBRequest> IDBObjectStore::clear(ScriptExecutionContext* context, ExceptionCode& ec)
{
LOG(StorageAPI, "IDBObjectStore::clear");
if (m_deleted) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
if (m_transaction->isReadOnly()) {
ec = IDBDatabaseException::ReadOnlyError;
return 0;
}
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
backendDB()->clearObjectStore(m_transaction->id(), id(), request);
return request.release();
}
