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(); }