RefPtr<WebCore::IDBRequest> IDBCursor::update(JSC::ExecState& exec, Deprecated::ScriptValue& value, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBCursor::update");
if (sourcesDeleted()) {
ec.code = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (!transaction().isActive()) {
ec.code = IDBDatabaseException::TransactionInactiveError;
ec.message = ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The transaction is inactive or finished.");
return nullptr;
}
if (transaction().isReadOnly()) {
ec.code = IDBDatabaseException::ReadOnlyError;
ec.message = ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The record may not be updated inside a read-only transaction.");
return nullptr;
}
if (!m_gotValue) {
ec.code = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (isKeyCursor()) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The cursor is a key cursor.");
return nullptr;
}
auto& objectStore = effectiveObjectStore();
auto& keyPath = objectStore.info().keyPath();
const bool usesInLineKeys = !keyPath.isNull();
if (usesInLineKeys) {
RefPtr<IDBKey> keyPathKey = maybeCreateIDBKeyFromScriptValueAndKeyPath(exec, value, keyPath);
IDBKeyData keyPathKeyData(keyPathKey.get());
if (!keyPathKey || keyPathKeyData != m_currentPrimaryKeyData) {
ec.code = IDBDatabaseException::DataError;
ec.message = ASCIILiteral("Failed to execute 'update' on 'IDBCursor': The effective object store of this cursor uses in-line keys and evaluating the key path of the value parameter results in a different value than the cursor's effective key.");
return nullptr;
}
}
auto request = effectiveObjectStore().putForCursorUpdate(exec, value.jsValue(), m_deprecatedCurrentPrimaryKey.jsValue(), ec);
if (ec.code)
return nullptr;
ASSERT(request);
request->setSource(*this);
return request;
}
RefPtr<WebCore::IDBRequest> IDBCursor::deleteFunction(ScriptExecutionContext* context, ExceptionCode& ec)
{
LOG(IndexedDB, "IDBCursor::deleteFunction");
if (!context) {
ec = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (sourcesDeleted()) {
ec = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (!transaction().isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return nullptr;
}
if (transaction().isReadOnly()) {
ec = IDBDatabaseException::ReadOnlyError;
return nullptr;
}
if (!m_gotValue) {
ec = IDBDatabaseException::InvalidStateError;
return nullptr;
}
return effectiveObjectStore().deleteFunction(context, m_deprecatedCurrentPrimaryKey.jsValue(), ec);
}
PassRefPtr<IDBRequest> IDBCursor::deleteFunction(ScriptExecutionContext* context, ExceptionCode& ec)
{
ec = 0;
IDB_TRACE("IDBCursor::delete");
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
if (m_transaction->isReadOnly()) {
ec = IDBDatabaseException::ReadOnlyError;
return 0;
}
if (!m_gotValue || isKeyCursor() || isDeleted()) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
RefPtr<IDBKeyRange> keyRange = IDBKeyRange::only(m_currentPrimaryKey, ec);
ASSERT(!ec);
RefPtr<IDBRequest> request = IDBRequest::create(context, IDBAny::create(this), m_transaction.get());
m_transaction->backendDB()->deleteRange(m_transaction->id(), effectiveObjectStore()->id(), keyRange, request);
return request.release();
}
PassRefPtr<IDBRequest> IDBCursor::update(ScriptExecutionContext* context, ScriptValue& value, ExceptionCode& ec)
{
IDB_TRACE("IDBCursor::update");
if (!m_gotValue || isKeyCursor()) {
ec = IDBDatabaseException::IDB_INVALID_STATE_ERR;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TRANSACTION_INACTIVE_ERR;
return 0;
}
if (m_transaction->isReadOnly()) {
ec = IDBDatabaseException::READ_ONLY_ERR;
return 0;
}
RefPtr<IDBObjectStore> objectStore = effectiveObjectStore();
const IDBKeyPath& keyPath = objectStore->metadata().keyPath;
const bool usesInLineKeys = !keyPath.isNull();
if (usesInLineKeys) {
RefPtr<IDBKey> keyPathKey = createIDBKeyFromScriptValueAndKeyPath(value, keyPath);
if (!keyPathKey || !keyPathKey->isEqual(m_currentPrimaryKey.get())) {
ec = IDBDatabaseException::DATA_ERR;
return 0;
}
}
return objectStore->put(IDBObjectStoreBackendInterface::CursorUpdate, IDBAny::create(this), context, value, m_currentPrimaryKey, ec);
}
void IDBRequest::onSuccess(PassRefPtr<SerializedScriptValue> prpSerializedScriptValue, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
{
IDB_TRACE("IDBRequest::onSuccess(SerializedScriptValue, IDBKey, IDBKeyPath)");
if (!shouldEnqueueEvent())
return;
#if USE(V8)
v8::HandleScope handleScope;
v8::Local<v8::Context> context = toV8Context(scriptExecutionContext(), m_worldContextHandle);
if (context.IsEmpty())
CRASH();
v8::Context::Scope contextScope(context);
#endif
#ifndef NDEBUG
ASSERT(keyPath == effectiveObjectStore(m_source)->keyPath());
#endif
ScriptValue value = deserializeIDBValue(scriptExecutionContext(), prpSerializedScriptValue);
RefPtr<IDBKey> primaryKey = prpPrimaryKey;
#ifndef NDEBUG
RefPtr<IDBKey> expectedKey = createIDBKeyFromScriptValueAndKeyPath(value, keyPath);
ASSERT(!expectedKey || expectedKey->isEqual(primaryKey.get()));
#endif
bool injected = injectIDBKeyIntoScriptValue(primaryKey, value, keyPath);
ASSERT_UNUSED(injected, injected);
onSuccessInternal(value);
}
RefPtr<WebCore::IDBRequest> IDBCursor::update(JSC::ExecState& exec, Deprecated::ScriptValue& value, ExceptionCode& ec)
{
LOG(IndexedDB, "IDBCursor::update");
if (sourcesDeleted()) {
ec = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (!transaction().isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return nullptr;
}
if (transaction().isReadOnly()) {
ec = IDBDatabaseException::ReadOnlyError;
return nullptr;
}
if (!m_gotValue) {
ec = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (isKeyCursor()) {
ec = IDBDatabaseException::InvalidStateError;
return nullptr;
}
return effectiveObjectStore().put(exec, value.jsValue(), m_deprecatedCurrentPrimaryKey.jsValue(), ec);
}
void IDBRequest::onSuccess(PassRefPtr<IDBValue> prpValue)
{
IDB_TRACE("IDBRequest::onSuccess(IDBValue)");
if (!shouldEnqueueEvent())
return;
RefPtr<IDBValue> value(prpValue);
ackReceivedBlobs(value.get());
if (m_pendingCursor) {
// Value should be null, signifying the end of the cursor's range.
ASSERT(value->isNull());
ASSERT(!value->blobInfo()->size());
m_pendingCursor->close();
m_pendingCursor.clear();
}
#if ENABLE(ASSERT)
if (value->primaryKey()) {
ASSERT(value->keyPath() == effectiveObjectStore(m_source)->metadata().keyPath);
assertPrimaryKeyValidOrInjectable(m_scriptState.get(), value.get());
}
#endif
onSuccessInternal(IDBAny::create(value.release()));
}
void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> valueBuffer, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
{
LOG(StorageAPI, "IDBRequest::onSuccess(SharedBuffer, IDBKey, IDBKeyPath)");
if (!shouldEnqueueEvent())
return;
#ifndef NDEBUG
ASSERT(keyPath == effectiveObjectStore(m_source)->keyPath());
#endif
DOMRequestState::Scope scope(m_requestState);
// FIXME: By not knowing whether or not the key is defined here, we don't know
// if a null valueBuffer means the value is null or the value is undefined.
Deprecated::ScriptValue value = deserializeIDBValueBuffer(requestState(), valueBuffer, true);
RefPtr<IDBKey> primaryKey = prpPrimaryKey;
if (!keyPath.isNull()) {
#ifndef NDEBUG
RefPtr<IDBKey> expectedKey = createIDBKeyFromScriptValueAndKeyPath(requestState()->exec(), value, keyPath);
ASSERT(!expectedKey || expectedKey->isEqual(primaryKey.get()));
#endif
bool injected = injectIDBKeyIntoScriptValue(requestState(), primaryKey, value, keyPath);
ASSERT_UNUSED(injected, injected);
}
onSuccessInternal(value);
}
void IDBCursor::setValueReady(DOMRequestState* state, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, ScriptValue& value)
{
m_currentKey = key;
m_currentKeyValue = idbKeyToScriptValue(state, m_currentKey);
m_currentPrimaryKey = primaryKey;
m_currentPrimaryKeyValue = idbKeyToScriptValue(state, m_currentPrimaryKey);
if (!isKeyCursor()) {
RefPtr<IDBObjectStore> objectStore = effectiveObjectStore();
const IDBObjectStoreMetadata metadata = objectStore->metadata();
if (metadata.autoIncrement && !metadata.keyPath.isNull()) {
#ifndef NDEBUG
RefPtr<IDBKey> expectedKey = createIDBKeyFromScriptValueAndKeyPath(m_request->requestState(), value, metadata.keyPath);
ASSERT(!expectedKey || expectedKey->isEqual(m_currentPrimaryKey.get()));
#endif
bool injected = injectIDBKeyIntoScriptValue(m_request->requestState(), m_currentPrimaryKey, value, metadata.keyPath);
// FIXME: There is no way to report errors here. Move this into onSuccessWithContinuation so that we can abort the transaction there. See: https://bugs.webkit.org/show_bug.cgi?id=92278
ASSERT_UNUSED(injected, injected);
}
}
m_currentValue = value;
m_gotValue = true;
}
PassRefPtr<IDBRequest> IDBCursor::update(ScriptState* state, ScriptValue& value, ExceptionCode& ec)
{
IDB_TRACE("IDBCursor::update");
if (!m_gotValue || isKeyCursor()) {
ec = IDBDatabaseException::InvalidStateError;
return 0;
}
if (!m_transaction->isActive()) {
ec = IDBDatabaseException::TransactionInactiveError;
return 0;
}
if (m_transaction->isReadOnly()) {
ec = IDBDatabaseException::ReadOnlyError;
return 0;
}
RefPtr<IDBObjectStore> objectStore = effectiveObjectStore();
const IDBKeyPath& keyPath = objectStore->metadata().keyPath;
const bool usesInLineKeys = !keyPath.isNull();
if (usesInLineKeys) {
RefPtr<IDBKey> keyPathKey = createIDBKeyFromScriptValueAndKeyPath(m_request->requestState(), value, keyPath);
if (!keyPathKey || !keyPathKey->isEqual(m_currentPrimaryKey.get())) {
ec = IDBDatabaseException::DataError;
return 0;
}
}
return objectStore->put(IDBDatabaseBackendInterface::CursorUpdate, IDBAny::create(this), state, value, m_currentPrimaryKey, ec);
}
IDBRequest* IDBCursor::update(ScriptState* scriptState, const ScriptValue& value, ExceptionState& exceptionState)
{
IDB_TRACE("IDBCursor::update");
if (!m_gotValue) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
return nullptr;
}
if (isKeyCursor()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::isKeyCursorErrorMessage);
return nullptr;
}
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
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, "The record may not be updated inside a read-only transaction.");
return nullptr;
}
IDBObjectStore* objectStore = effectiveObjectStore();
return objectStore->put(scriptState, WebIDBPutModeCursorUpdate, IDBAny::create(this), value, m_primaryKey, exceptionState);
}
void IDBCursor::setValueReady(PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SerializedScriptValue> prpValue)
{
m_currentKey = key;
m_currentPrimaryKey = primaryKey;
RefPtr<SerializedScriptValue> value = prpValue;
if (!isKeyCursor()) {
RefPtr<IDBObjectStore> objectStore = effectiveObjectStore();
const IDBObjectStoreMetadata metadata = objectStore->metadata();
if (metadata.autoIncrement && !metadata.keyPath.isNull()) {
#ifndef NDEBUG
RefPtr<IDBKey> expectedKey = createIDBKeyFromSerializedValueAndKeyPath(value, metadata.keyPath);
ASSERT(!expectedKey || expectedKey->isEqual(m_currentPrimaryKey.get()));
#endif
RefPtr<SerializedScriptValue> valueAfterInjection = injectIDBKeyIntoSerializedValue(m_currentPrimaryKey, value, metadata.keyPath);
ASSERT(valueAfterInjection);
// FIXME: There is no way to report errors here. Move this into onSuccessWithContinuation so that we can abort the transaction there. See: https://bugs.webkit.org/show_bug.cgi?id=92278
if (valueAfterInjection)
value = valueAfterInjection;
}
}
m_currentValue = IDBAny::create(value.release());
m_gotValue = true;
m_valueIsDirty = true;
}
void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> prpValueBuffer, PassOwnPtr<Vector<WebBlobInfo> > blobInfo, IDBKey* prpPrimaryKey, const IDBKeyPath& keyPath)
{
IDB_TRACE("IDBRequest::onSuccess(SharedBuffer, IDBKey, IDBKeyPath)");
if (!shouldEnqueueEvent())
return;
ASSERT(keyPath == effectiveObjectStore(m_source)->metadata().keyPath);
RefPtr<SharedBuffer> valueBuffer = prpValueBuffer;
IDBKey* primaryKey = prpPrimaryKey;
setBlobInfo(blobInfo);
#if ENABLE(ASSERT)
assertPrimaryKeyValidOrInjectable(m_scriptState.get(), valueBuffer, m_blobInfo.get(), primaryKey, keyPath);
#endif
onSuccessInternal(IDBAny::create(valueBuffer, m_blobInfo.get(), primaryKey, keyPath));
}
void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> prpValueBuffer, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
{
IDB_TRACE("IDBRequest::onSuccess(SharedBuffer, IDBKey, IDBKeyPath)");
if (!shouldEnqueueEvent())
return;
#ifndef NDEBUG
ASSERT(keyPath == effectiveObjectStore(m_source)->metadata().keyPath);
#endif
RefPtr<SharedBuffer> valueBuffer = prpValueBuffer;
RefPtr<IDBKey> primaryKey = prpPrimaryKey;
#ifndef NDEBUG
assertPrimaryKeyValidOrInjectable(&m_requestState, valueBuffer, primaryKey, keyPath);
#endif
onSuccessInternal(IDBAny::create(valueBuffer, primaryKey, keyPath));
}
IDBRequest* IDBCursor::update(ScriptState* scriptState, ScriptValue& value, ExceptionState& exceptionState)
{
IDB_TRACE("IDBCursor::update");
if (!m_gotValue) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
return 0;
}
if (isKeyCursor()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::isKeyCursorErrorMessage);
return 0;
}
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
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 (m_transaction->isReadOnly()) {
exceptionState.throwDOMException(ReadOnlyError, "The record may not be updated inside a read-only transaction.");
return 0;
}
IDBObjectStore* objectStore = effectiveObjectStore();
const IDBKeyPath& keyPath = objectStore->metadata().keyPath;
const bool usesInLineKeys = !keyPath.isNull();
if (usesInLineKeys) {
IDBKey* keyPathKey = createIDBKeyFromScriptValueAndKeyPath(scriptState->isolate(), value, keyPath);
if (!keyPathKey || !keyPathKey->isEqual(m_primaryKey.get())) {
exceptionState.throwDOMException(DataError, "The effective object store of this cursor uses in-line keys and evaluating the key path of the value parameter results in a different value than the cursor's effective key.");
return 0;
}
}
return objectStore->put(scriptState, blink::WebIDBPutModeCursorUpdate, IDBAny::create(this), value, m_primaryKey, exceptionState);
}
ScriptValue IDBCursor::value(ScriptState* scriptState)
{
ASSERT(isCursorWithValue());
IDBObjectStore* objectStore = effectiveObjectStore();
const IDBObjectStoreMetadata& metadata = objectStore->metadata();
IDBAny* value;
if (metadata.autoIncrement && !metadata.keyPath.isNull()) {
value = IDBAny::create(m_value, m_blobs->getInfo(), m_primaryKey, metadata.keyPath);
#if ENABLE(ASSERT)
assertPrimaryKeyValidOrInjectable(scriptState, m_value, m_blobs->getInfo(), m_primaryKey, metadata.keyPath);
#endif
} else {
value = IDBAny::create(m_value, m_blobs->getInfo());
}
m_valueDirty = false;
ScriptValue scriptValue = idbAnyToScriptValue(scriptState, value);
return scriptValue;
}
void IDBRequest::onSuccess(PassRefPtr<SerializedScriptValue> prpSerializedScriptValue, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
{
IDB_TRACE("IDBRequest::onSuccess(SerializedScriptValue, IDBKey, IDBKeyPath)");
if (!shouldEnqueueEvent())
return;
#ifndef NDEBUG
ASSERT(keyPath == effectiveObjectStore(m_source)->keyPath());
#endif
ScriptValue value = deserializeIDBValue(scriptExecutionContext(), prpSerializedScriptValue);
RefPtr<IDBKey> primaryKey = prpPrimaryKey;
#ifndef NDEBUG
RefPtr<IDBKey> expectedKey = createIDBKeyFromScriptValueAndKeyPath(value, keyPath);
ASSERT(!expectedKey || expectedKey->isEqual(primaryKey.get()));
#endif
bool injected = injectIDBKeyIntoScriptValue(primaryKey, value, keyPath);
ASSERT_UNUSED(injected, injected);
onSuccessInternal(value);
}
ScriptValue IDBCursor::value(ScriptState* scriptState)
{
ASSERT(isCursorWithValue());
RefPtrWillBeRawPtr<IDBObjectStore> objectStore = effectiveObjectStore();
const IDBObjectStoreMetadata& metadata = objectStore->metadata();
RefPtrWillBeRawPtr<IDBAny> value;
if (metadata.autoIncrement && !metadata.keyPath.isNull()) {
value = IDBAny::create(m_value, m_blobInfo.get(), m_primaryKey, metadata.keyPath);
#ifndef NDEBUG
assertPrimaryKeyValidOrInjectable(scriptState, m_value, m_blobInfo.get(), m_primaryKey, metadata.keyPath);
#endif
} else {
value = IDBAny::create(m_value, m_blobInfo.get());
}
m_valueDirty = false;
ScriptValue scriptValue = idbAnyToScriptValue(scriptState, value);
handleBlobAcks();
return scriptValue;
}
void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> valueBuffer, PassRefPtr<IDBKey> prpPrimaryKey, const IDBKeyPath& keyPath)
{
IDB_TRACE("IDBRequest::onSuccess(SharedBuffer, IDBKey, IDBKeyPath)");
if (!shouldEnqueueEvent())
return;
#ifndef NDEBUG
ASSERT(keyPath == effectiveObjectStore(m_source)->keyPath());
#endif
DOMRequestState::Scope scope(m_requestState);
ScriptValue value = deserializeIDBValueBuffer(requestState(), valueBuffer);
RefPtr<IDBKey> primaryKey = prpPrimaryKey;
#ifndef NDEBUG
RefPtr<IDBKey> expectedKey = createIDBKeyFromScriptValueAndKeyPath(requestState(), value, keyPath);
ASSERT(!expectedKey || expectedKey->isEqual(primaryKey.get()));
#endif
bool injected = injectIDBKeyIntoScriptValue(requestState(), primaryKey, value, keyPath);
ASSERT_UNUSED(injected, injected);
onSuccessInternal(value);
}
IDBRequest* IDBCursor::deleteFunction(ScriptState* scriptState, ExceptionState& exceptionState)
{
IDB_TRACE("IDBCursor::delete");
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, "The record may not be deleted inside a read-only transaction.");
return nullptr;
}
if (!m_gotValue) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::noValueErrorMessage);
return nullptr;
}
if (isKeyCursor()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::isKeyCursorErrorMessage);
return nullptr;
}
if (isDeleted()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::sourceDeletedErrorMessage);
return nullptr;
}
if (!m_transaction->backendDB()) {
exceptionState.throwDOMException(InvalidStateError, IDBDatabase::databaseClosedErrorMessage);
return nullptr;
}
IDBKeyRange* keyRange = IDBKeyRange::only(m_primaryKey, exceptionState);
ASSERT(!exceptionState.hadException());
IDBRequest* request = IDBRequest::create(scriptState, IDBAny::create(this), m_transaction.get());
m_transaction->backendDB()->deleteRange(m_transaction->id(), effectiveObjectStore()->id(), keyRange, WebIDBCallbacksImpl::create(request).leakPtr());
return request;
}
RefPtr<WebCore::IDBRequest> IDBCursor::deleteFunction(ScriptExecutionContext* context, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBCursor::deleteFunction");
if (!context) {
ec.code = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (sourcesDeleted()) {
ec.code = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (!transaction().isActive()) {
ec.code = IDBDatabaseException::TransactionInactiveError;
ec.message = ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The transaction is inactive or finished.");
return nullptr;
}
if (transaction().isReadOnly()) {
ec.code = IDBDatabaseException::ReadOnlyError;
ec.message = ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The record may not be deleted inside a read-only transaction.");
return nullptr;
}
if (!m_gotValue) {
ec.code = IDBDatabaseException::InvalidStateError;
return nullptr;
}
if (isKeyCursor()) {
ec.code = IDBDatabaseException::InvalidStateError;
ec.message = ASCIILiteral("Failed to execute 'delete' on 'IDBCursor': The cursor is a key cursor.");
return nullptr;
}
return effectiveObjectStore().deleteFunction(context, m_deprecatedCurrentPrimaryKey.jsValue(), ec);
}
ScriptValue IDBCursor::value(ScriptState* scriptState)
{
ASSERT(isCursorWithValue());
IDBObjectStore* objectStore = effectiveObjectStore();
const IDBObjectStoreMetadata& metadata = objectStore->metadata();
IDBAny* value;
if (!m_value) {
value = IDBAny::createUndefined();
} else if (metadata.autoIncrement && !metadata.keyPath.isNull()) {
RefPtr<IDBValue> idbValue = IDBValue::create(m_value.get(), m_primaryKey, metadata.keyPath);
#if ENABLE(ASSERT)
assertPrimaryKeyValidOrInjectable(scriptState, idbValue.get());
#endif
value = IDBAny::create(idbValue.release());
} else {
value = IDBAny::create(m_value);
}
m_valueDirty = false;
ScriptValue scriptValue = ScriptValue::from(scriptState, value);
return scriptValue;
}
IDBTransaction& IDBCursor::transaction() const
{
return effectiveObjectStore().modernTransaction();
}
