void IDBCursor::continueFunction(ScriptExecutionContext* context, const Deprecated::ScriptValue& keyValue, ExceptionCode& ec)
{
if (!context) {
ec = IDBDatabaseException::InvalidStateError;
return;
}
DOMRequestState requestState(context);
RefPtr<IDBKey> key = scriptValueToIDBKey(&requestState, keyValue);
continueFunction(key.get(), ec);
}
PassRefPtr<IDBKeyRange> IDBKeyRange::upperBound(ExecutionContext* context, const ScriptValue& boundValue, bool open, ExceptionState& es)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> bound = scriptValueToIDBKey(&requestState, boundValue);
if (!bound || !bound->isValid()) {
es.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
return IDBKeyRange::create(0, bound, LowerBoundOpen, open ? UpperBoundOpen : UpperBoundClosed);
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::deleteFunction(ScriptExecutionContext* context, JSC::JSValue key, ExceptionCode& ec)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
return deleteFunction(context, &IDBKeyRange::create(idbKey.get()).get(), ec);
}
PassRefPtr<IDBKeyRange> IDBKeyRange::only(ExecutionContext* context, const ScriptValue& keyValue, ExceptionState& es)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> key = scriptValueToIDBKey(&requestState, keyValue);
if (!key || !key->isValid()) {
es.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
return IDBKeyRange::create(key, key, LowerBoundClosed, UpperBoundClosed);
}
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);
}
void IDBRequest::onSuccess(PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> buffer)
{
IDB_TRACE("IDBRequest::onSuccess(key, primaryKey, value)");
if (!shouldEnqueueEvent())
return;
DOMRequestState::Scope scope(m_requestState);
ScriptValue value = deserializeIDBValueBuffer(requestState(), buffer);
ASSERT(m_pendingCursor);
setResultCursor(m_pendingCursor.release(), key, primaryKey, value);
enqueueEvent(createSuccessEvent());
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::deleteFunction(ScriptExecutionContext* context, JSC::JSValue key, ExceptionCodeWithMessage& ec)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec.code = IDBDatabaseException::DataError;
ec.message = ASCIILiteral("Failed to execute 'delete' on 'IDBObjectStore': The parameter is not a valid key.");
return nullptr;
}
return deleteFunction(context, &IDBKeyRange::create(idbKey.get()).get(), ec);
}
void IDBRequest::onSuccess(PassRefPtr<SharedBuffer> valueBuffer)
{
LOG(StorageAPI, "IDBRequest::onSuccess(SharedBuffer)");
if (!shouldEnqueueEvent())
return;
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);
onSuccessInternal(value);
}
void IDBRequest::onSuccess(PassRefPtr<IDBKey> idbKey)
{
IDB_TRACE("IDBRequest::onSuccess(IDBKey)");
if (!shouldEnqueueEvent())
return;
if (idbKey && idbKey->isValid()) {
DOMRequestState::Scope scope(m_requestState);
m_result = IDBAny::create(idbKeyToScriptValue(requestState(), idbKey));
} else
m_result = IDBAny::createInvalid();
enqueueEvent(createSuccessEvent());
}
void LegacyRequest::onSuccess(PassRefPtr<IDBKey> idbKey)
{
LOG(StorageAPI, "LegacyRequest::onSuccess(IDBKey)");
if (!shouldEnqueueEvent())
return;
if (idbKey && idbKey->isValid()) {
DOMRequestState::Scope scope(m_requestState);
m_result = LegacyAny::create(idbKeyToScriptValue(requestState(), idbKey));
} else
m_result = LegacyAny::createInvalid();
enqueueEvent(createSuccessEvent());
}
RefPtr<IDBRequest> IDBIndex::getKey(ScriptExecutionContext& context, const Deprecated::ScriptValue& key, ExceptionCodeWithMessage& ec)
{
LOG(IndexedDB, "IDBIndex::getKey");
DOMRequestState requestState(&context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec.code = IDBDatabaseException::DataError;
ec.message = ASCIILiteral("Failed to execute 'getKey' on 'IDBIndex': The parameter is not a valid key.");
return nullptr;
}
return doGetKey(context, IDBKeyRangeData(idbKey.get()), ec);
}
void LegacyRequest::onSuccess(PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> buffer)
{
LOG(StorageAPI, "LegacyRequest::onSuccess(key, primaryKey, valueBuffer)");
if (!shouldEnqueueEvent())
return;
DOMRequestState::Scope scope(m_requestState);
Deprecated::ScriptValue value = deserializeIDBValueBuffer(requestState(), buffer, !!key);
ASSERT(m_pendingCursor);
setResultCursor(m_pendingCursor.release(), key, primaryKey, value);
enqueueEvent(createSuccessEvent());
}
short IDBFactory::cmp(ScriptExecutionContext* context, const Deprecated::ScriptValue& firstValue, const Deprecated::ScriptValue& secondValue, ExceptionCode& ec)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> first = scriptValueToIDBKey(&requestState, firstValue);
RefPtr<IDBKey> second = scriptValueToIDBKey(&requestState, secondValue);
ASSERT(first);
ASSERT(second);
if (!first->isValid() || !second->isValid()) {
ec = IDBDatabaseException::DataError;
return 0;
}
return static_cast<short>(first->compare(second.get()));
}
short IDBFactory::cmp(ScriptExecutionContext* context, const Deprecated::ScriptValue& firstValue, const Deprecated::ScriptValue& secondValue, ExceptionCodeWithMessage& ec)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> first = scriptValueToIDBKey(&requestState, firstValue);
RefPtr<IDBKey> second = scriptValueToIDBKey(&requestState, secondValue);
ASSERT(first);
ASSERT(second);
if (!first->isValid() || !second->isValid()) {
ec.code = IDBDatabaseException::DataError;
ec.message = ASCIILiteral("Failed to execute 'cmp' on 'IDBFactory': The parameter is not a valid key.");
return 0;
}
return static_cast<short>(first->compare(second.get()));
}
PassRefPtr<IDBKeyRange> IDBKeyRange::fromScriptValue(ExecutionContext* context, const ScriptValue& value, ExceptionState& es)
{
DOMRequestState requestState(context);
if (value.isUndefined() || value.isNull())
return 0;
RefPtr<IDBKeyRange> range = scriptValueToIDBKeyRange(&requestState, value);
if (range)
return range.release();
RefPtr<IDBKey> key = scriptValueToIDBKey(&requestState, value);
if (!key || !key->isValid()) {
es.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
return adoptRef(new IDBKeyRange(key, key, LowerBoundClosed, UpperBoundClosed));
}
RefPtr<WebCore::IDBRequest> IDBObjectStore::count(ScriptExecutionContext* context, const Deprecated::ScriptValue& key, ExceptionCode& ec)
{
LOG(IndexedDB, "IDBObjectStore::count");
if (!context) {
ec = INVALID_STATE_ERR;
return nullptr;
}
DOMRequestState requestState(context);
RefPtr<IDBKey> idbKey = scriptValueToIDBKey(&requestState, key);
if (!idbKey || idbKey->type() == KeyType::Invalid) {
ec = static_cast<ExceptionCode>(IDBExceptionCode::DataError);
return nullptr;
}
return doCount(*context, IDBKeyRangeData(idbKey.get()), ec);
}
v8::Handle<v8::Value> requestState(const v8::Arguments& args)
{
v8::HandleScope scope;
std::string value;
if(args.Length() == 2)
{
v8::String::AsciiValue actor(args[0]->ToString());
v8::String::AsciiValue state(args[1]->ToString());
value = requestState(*actor, *state);
return scope.Close(v8::String::New(value.c_str()));
}
else
{
return scope.Close(v8::String::New("N/A"));
}
}
PassRefPtr<IDBKeyRange> IDBKeyRange::bound(ScriptExecutionContext* context, const ScriptValue& lowerValue, const ScriptValue& upperValue, bool lowerOpen, bool upperOpen, ExceptionState& es)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> lower = scriptValueToIDBKey(&requestState, lowerValue);
RefPtr<IDBKey> upper = scriptValueToIDBKey(&requestState, upperValue);
if (!lower || !lower->isValid() || !upper || !upper->isValid()) {
es.throwDOMException(DataError, IDBDatabase::notValidKeyErrorMessage);
return 0;
}
if (upper->isLessThan(lower.get())) {
es.throwDOMException(DataError, "The lower key is greater than the upper key.");
return 0;
}
if (upper->isEqual(lower.get()) && (lowerOpen || upperOpen)) {
es.throwDOMException(DataError, "The lower key and upper key are equal and one of the bounds is open.");
return 0;
}
return IDBKeyRange::create(lower, upper, lowerOpen ? LowerBoundOpen : LowerBoundClosed, upperOpen ? UpperBoundOpen : UpperBoundClosed);
}
ScriptPromise PushRegistrationManager::hasPermissionPush(ExecutionContext* executionContext)
{
ScriptPromise promise = ScriptPromise::createPending(executionContext);
RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(promise, executionContext);
if (m_pushPermission != PushPermission::Default) {
DOMRequestState requestState(executionContext);
v8::Isolate* isolate = requestState.isolate();
PushPermission::PermissionType permission =
(permission == PushPermission::InProgress) ? PushPermission::Default : m_pushPermission;
resolver->resolve(ScriptValue(v8AtomicString(isolate, PushPermission::permissionString(m_pushPermission).utf8().data()), isolate));
return promise;
}
m_pushController->client()->hasPermissionPush(
blink::WebSecurityOrigin(executionContext->securityOrigin()),
new CallbackPromiseAdapterContext<PushPermission, PushError>(resolver, executionContext));
return promise;
}
bool DefaultLocalizer::fetch( const std::string& port, Transformation& out )
{
requestState( ready );
std::vector< CToolData* > tdv;
CToolData td;
td.bVisible = false;
td.setSzPort( port );
tdv.push_back( &td );
pimpl->localizer.getToolData( tdv );
if( td.isVisible() )
{
for( int i = 0; i < 3; ++i )
for( int j = 0; j < 3; ++j )
{
out.getTransformationMatrix()( i, j ) = td.mR( i, j );
}
for( int i = 0; i < 3; ++i )
{
out.getTransformationMatrix()( i, 3 ) = td.vT( i );
}
out.a44() = 1;
return true;
}
else
{
return false;
}
}
void DefaultLocalizer::loadFromIni( const std::string& iniFile )
{
requestState( asleep );
QFileInfo iniFileInfo( QString::fromStdString( iniFile ) );
if( iniFileInfo.exists() )
{
QString iniFileName( iniFileInfo.fileName() );
QString iniFilePath( iniFileInfo.absolutePath() );
QApplication::setOverrideCursor( Qt::WaitCursor );
bool success = !pimpl->localizer.open( iniFilePath.toStdString(), iniFileName.toStdString() );
QApplication::restoreOverrideCursor();
if( !success )
{
throw illegalIniFile();
}
}
else
{
throw missingIniFile();
}
}
void IDBRequest::onSuccess(PassRefPtr<IDBCursorBackendInterface> backend, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SharedBuffer> buffer)
{
IDB_TRACE("IDBRequest::onSuccess(IDBCursor)");
if (!shouldEnqueueEvent())
return;
DOMRequestState::Scope scope(m_requestState);
ScriptValue value = deserializeIDBValueBuffer(requestState(), buffer);
ASSERT(!m_pendingCursor);
RefPtr<IDBCursor> cursor;
switch (m_cursorType) {
case IndexedDB::CursorKeyOnly:
cursor = IDBCursor::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
break;
case IndexedDB::CursorKeyAndValue:
cursor = IDBCursorWithValue::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get());
break;
default:
ASSERT_NOT_REACHED();
}
setResultCursor(cursor, key, primaryKey, value);
enqueueEvent(createSuccessEvent());
}
ScriptValue IDBRequest::source(ExecutionContext* context) const
{
DOMRequestState requestState(context);
return idbAnyToScriptValue(&requestState, m_source);
}
bool IDBRequest::dispatchEvent(PassRefPtr<Event> event)
{
IDB_TRACE("IDBRequest::dispatchEvent");
ASSERT(m_readyState == PENDING);
ASSERT(!m_contextStopped);
ASSERT(m_hasPendingActivity);
ASSERT(m_enqueuedEvents.size());
ASSERT(scriptExecutionContext());
ASSERT(event->target() == this);
ASSERT_WITH_MESSAGE(m_readyState < DONE, "When dispatching event %s, m_readyState < DONE(%d), was %d", event->type().string().utf8().data(), DONE, m_readyState);
DOMRequestState::Scope scope(m_requestState);
if (event->type() != eventNames().blockedEvent)
m_readyState = DONE;
for (size_t i = 0; i < m_enqueuedEvents.size(); ++i) {
if (m_enqueuedEvents[i].get() == event.get())
m_enqueuedEvents.remove(i);
}
Vector<RefPtr<EventTarget> > targets;
targets.append(this);
if (m_transaction && !m_preventPropagation) {
targets.append(m_transaction);
// If there ever are events that are associated with a database but
// that do not have a transaction, then this will not work and we need
// this object to actually hold a reference to the database (to ensure
// it stays alive).
targets.append(m_transaction->db());
}
// Cursor properties should not updated until the success event is being dispatched.
RefPtr<IDBCursor> cursorToNotify;
if (event->type() == eventNames().successEvent) {
cursorToNotify = getResultCursor();
if (cursorToNotify) {
cursorToNotify->setValueReady(requestState(), m_cursorKey.release(), m_cursorPrimaryKey.release(), m_cursorValue);
m_cursorValue.clear();
}
}
if (event->type() == eventNames().upgradeneededEvent) {
ASSERT(!m_didFireUpgradeNeededEvent);
m_didFireUpgradeNeededEvent = true;
}
// FIXME: When we allow custom event dispatching, this will probably need to change.
ASSERT_WITH_MESSAGE(event->type() == eventNames().successEvent || event->type() == eventNames().errorEvent || event->type() == eventNames().blockedEvent || event->type() == eventNames().upgradeneededEvent, "event type was %s", event->type().string().utf8().data());
const bool setTransactionActive = m_transaction && (event->type() == eventNames().successEvent || event->type() == eventNames().upgradeneededEvent || (event->type() == eventNames().errorEvent && m_errorCode != IDBDatabaseException::AbortError));
if (setTransactionActive)
m_transaction->setActive(true);
bool dontPreventDefault = IDBEventDispatcher::dispatch(event.get(), targets);
if (m_transaction) {
if (m_readyState == DONE)
m_transaction->unregisterRequest(this);
// Possibly abort the transaction. This must occur after unregistering (so this request
// doesn't receive a second error) and before deactivating (which might trigger commit).
if (event->type() == eventNames().errorEvent && dontPreventDefault && !m_requestAborted) {
m_transaction->setError(m_error, m_errorMessage);
m_transaction->abort(IGNORE_EXCEPTION);
}
// If this was the last request in the transaction's list, it may commit here.
if (setTransactionActive)
m_transaction->setActive(false);
}
if (cursorToNotify)
cursorToNotify->postSuccessHandlerCallback();
if (m_readyState == DONE && (!cursorToNotify || m_cursorFinished) && event->type() != eventNames().upgradeneededEvent)
m_hasPendingActivity = false;
return dontPreventDefault;
}
void IDBRequest::onSuccessInternal(PassRefPtr<SerializedScriptValue> value)
{
ASSERT(!m_contextStopped);
DOMRequestState::Scope scope(m_requestState);
return onSuccessInternal(deserializeIDBValue(requestState(), value));
}
void IDBCursor::continueFunction(ScriptExecutionContext* context, const ScriptValue& keyValue, ExceptionCode& ec)
{
DOMRequestState requestState(context);
RefPtr<IDBKey> key = scriptValueToIDBKey(&requestState, keyValue);
continueFunction(key.release(), ec);
}
Deprecated::ScriptValue idbKeyDataToScriptValue(ScriptExecutionContext* context, const IDBKeyData& keyData)
{
RefPtr<IDBKey> key = keyData.maybeCreateIDBKey();
DOMRequestState requestState(context);
return idbKeyToScriptValue(&requestState, key.get());
}
ScriptValue IDBIndex::keyPath(ExecutionContext* context) const
{
DOMRequestState requestState(context);
return idbAnyToScriptValue(&requestState, IDBAny::create(m_metadata.keyPath));
}
PassRefPtr<IDBRequest> IDBObjectStore::put(IDBDatabaseBackend::PutMode putMode, PassRefPtr<IDBAny> source, JSC::ExecState* state, Deprecated::ScriptValue& value, PassRefPtr<IDBKey> prpKey, ExceptionCode& ec)
{
RefPtr<IDBKey> key = prpKey;
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;
}
// FIXME: Expose the JS engine exception state through ScriptState.
bool didThrow = false;
RefPtr<SerializedScriptValue> serializedValue = SerializedScriptValue::serialize(value, state, nullptr, nullptr, didThrow);
if (didThrow) {
// Setting an explicit ExceptionCode here would defer handling the already thrown exception.
return 0;
}
if (serializedValue->hasBlobURLs()) {
// FIXME: Add Blob/File/FileList support
ec = IDBDatabaseException::DataCloneError;
return 0;
}
const IDBKeyPath& keyPath = m_metadata.keyPath;
const bool usesInLineKeys = !keyPath.isNull();
const bool hasKeyGenerator = autoIncrement();
ScriptExecutionContext* context = scriptExecutionContextFromExecState(state);
DOMRequestState requestState(context);
if (putMode != IDBDatabaseBackend::CursorUpdate && usesInLineKeys && key) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (!usesInLineKeys && !hasKeyGenerator && !key) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (usesInLineKeys) {
RefPtr<IDBKey> keyPathKey = createIDBKeyFromScriptValueAndKeyPath(&requestState, value, keyPath);
if (keyPathKey && !keyPathKey->isValid()) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (!hasKeyGenerator && !keyPathKey) {
ec = IDBDatabaseException::DataError;
return 0;
}
if (hasKeyGenerator && !keyPathKey) {
if (!canInjectIDBKeyIntoScriptValue(&requestState, value, keyPath)) {
ec = IDBDatabaseException::DataError;
return 0;
}
}
if (keyPathKey)
key = keyPathKey;
}
if (key && !key->isValid()) {
ec = IDBDatabaseException::DataError;
return 0;
}
Vector<int64_t> indexIds;
Vector<IndexKeys> indexKeys;
for (IDBObjectStoreMetadata::IndexMap::const_iterator it = m_metadata.indexes.begin(); it != m_metadata.indexes.end(); ++it) {
IndexKeys keys;
generateIndexKeysForValue(&requestState, it->value, value, &keys);
indexIds.append(it->key);
indexKeys.append(keys);
}
RefPtr<IDBRequest> request = IDBRequest::create(context, source, m_transaction.get());
Vector<uint8_t> valueBytes = serializedValue->toWireBytes();
// This is a hack to account for disagreements about whether SerializedScriptValue should deal in Vector<uint8_t> or Vector<char>.
// See https://lists.webkit.org/pipermail/webkit-dev/2013-February/023682.html
Vector<char>* valueBytesSigned = reinterpret_cast<Vector<char>*>(&valueBytes);
RefPtr<SharedBuffer> valueBuffer = SharedBuffer::adoptVector(*valueBytesSigned);
backendDB()->put(m_transaction->id(), id(), valueBuffer, key.release(), static_cast<IDBDatabaseBackend::PutMode>(putMode), request, indexIds, indexKeys);
return request.release();
}
ScriptValue IDBKeyRange::upperValue(ScriptExecutionContext* context) const
{
DOMRequestState requestState(context);
return idbKeyToScriptValue(&requestState, m_upper);
}