void PointerLockController::requestPointerLock(Element* target) { if (!target || !target->inDocument() || m_documentOfRemovedElementWhileWaitingForUnlock) { enqueueEvent(EventTypeNames::pointerlockerror, target); return; } UseCounter::countCrossOriginIframe(target->document(), UseCounter::ElementRequestPointerLockIframe); if (target->document().isSandboxed(SandboxPointerLock)) { // FIXME: This message should be moved off the console once a solution to https://bugs.webkit.org/show_bug.cgi?id=103274 exists. target->document().addConsoleMessage(ConsoleMessage::create(SecurityMessageSource, ErrorMessageLevel, "Blocked pointer lock on an element because the element's frame is sandboxed and the 'allow-pointer-lock' permission is not set.")); enqueueEvent(EventTypeNames::pointerlockerror, target); return; } if (m_element) { if (m_element->document() != target->document()) { enqueueEvent(EventTypeNames::pointerlockerror, target); return; } enqueueEvent(EventTypeNames::pointerlockchange, target); m_element = target; } else if (m_page->chromeClient().requestPointerLock()) { m_lockPending = true; m_element = target; } else { enqueueEvent(EventTypeNames::pointerlockerror, target); } }
void PointerLockController::didLosePointerLock() { enqueueEvent(EventTypeNames::pointerlockchange, m_element ? &m_element->document() : m_documentOfRemovedElementWhileWaitingForUnlock.get()); enqueueEvent(EventTypeNames::webkitpointerlockchange, m_element ? &m_element->document() : m_documentOfRemovedElementWhileWaitingForUnlock.get()); clearElement(); m_documentOfRemovedElementWhileWaitingForUnlock = nullptr; }
void IDBOpenDBRequest::requestCompleted(const IDBResultData& data) { LOG(IndexedDB, "IDBOpenDBRequest::requestCompleted"); if (!data.error().isNull()) { LOG(IndexedDB, " with error: (%s) '%s'", data.error().name().utf8().data(), data.error().message().utf8().data()); m_domError = DOMError::create(data.error().name()); enqueueEvent(Event::create(eventNames().errorEvent, true, true)); } else enqueueEvent(Event::create(eventNames().successEvent, true, true)); }
void pollGamepads() { // This gamepad is an OR-ed version of all the other gamepads. If button // 3 is pressed on any attached gamepad, down(gpButton3) will return // true. This is handy for singleplayer games. GamepadBuffer anyGamepad = { false }; std::size_t availableGamepads = gameControllers.size() + joysticks.size(); for (int i = 0; i < availableGamepads; ++i) { GamepadBuffer currentGamepad = { false }; // Poll data from SDL, using either of two API interfaces. if (i < gameControllers.size()) { SDL_GameController *gameController = gameControllers[i]; pollGameController(gameController, currentGamepad); } else { SDL_Joystick *joystick = joysticks[i - gameControllers.size()]; pollJoystick(joystick, currentGamepad); } // Now at the same time, enqueue all events for this particular // gamepad, and OR the keyboard state into anyGamepad. int offset = gpRangeBegin + gpNumPerGamepad * (i + 1); for (int j = 0; j < currentGamepad.size(); ++j) { anyGamepad[j] = anyGamepad[j] || currentGamepad[j]; if (currentGamepad[j] && !buttonStates[j + offset]) { buttonStates[j + offset] = true; enqueueEvent(j + offset, true); } else if (!currentGamepad[j] && buttonStates[j + offset]) { buttonStates[j + offset] = false; enqueueEvent(j + offset, false); } } } // And lastly, enqueue events for the virtual "any" gamepad. for (int j = 0; j < anyGamepad.size(); ++j) { if (anyGamepad[j] && !buttonStates[j + gpRangeBegin]) { buttonStates[j + gpRangeBegin] = true; enqueueEvent(j + gpRangeBegin, true); } else if (!anyGamepad[j] && buttonStates[j + gpRangeBegin]) { buttonStates[j + gpRangeBegin] = false; enqueueEvent(j + gpRangeBegin, false); } } }
void GameState::enqueueRemove(Entity *ptr) { DelayedEvent event; event.type = EVENT_REMOVE; event.map = 0; enqueueEvent(ptr, event); }
void IDBRequest::onSuccessInternal(PassRefPtr<IDBAny> result) { ASSERT(!m_contextStopped); ASSERT(!m_pendingCursor); setResult(result); enqueueEvent(Event::create(EventTypeNames::success)); }
void IDBOpenDBRequest::onUpgradeNeeded(int64_t oldVersion, PassRefPtr<IDBTransactionBackendInterface> prpTransactionBackend, PassRefPtr<IDBDatabaseBackendInterface> prpDatabaseBackend) { IDB_TRACE("IDBOpenDBRequest::onUpgradeNeeded()"); if (m_contextStopped || !scriptExecutionContext()) { RefPtr<IDBTransactionBackendInterface> transaction = prpTransactionBackend; transaction->abort(); RefPtr<IDBDatabaseBackendInterface> db = prpDatabaseBackend; db->close(m_databaseCallbacks); return; } if (!shouldEnqueueEvent()) return; ASSERT(m_databaseCallbacks); RefPtr<IDBDatabaseBackendInterface> databaseBackend = prpDatabaseBackend; RefPtr<IDBTransactionBackendInterface> transactionBackend = prpTransactionBackend; RefPtr<IDBDatabase> idbDatabase = IDBDatabase::create(scriptExecutionContext(), databaseBackend, m_databaseCallbacks); m_databaseCallbacks->connect(idbDatabase.get()); m_databaseCallbacks = 0; int64_t transactionId = IDBDatabase::nextTransactionId(); RefPtr<IDBTransaction> frontend = IDBTransaction::create(scriptExecutionContext(), transactionId, transactionBackend, Vector<String>(), IDBTransaction::VERSION_CHANGE, idbDatabase.get(), this); transactionBackend->setCallbacks(frontend.get()); m_transaction = frontend; m_result = IDBAny::create(idbDatabase.release()); if (oldVersion == IDBDatabaseMetadata::NoIntVersion) { // This database hasn't had an integer version before. oldVersion = IDBDatabaseMetadata::DefaultIntVersion; } if (m_version == IDBDatabaseMetadata::NoIntVersion) m_version = 1; enqueueEvent(IDBUpgradeNeededEvent::create(oldVersion, m_version, eventNames().upgradeneededEvent)); }
void IDBRequest::onSuccess(PassRefPtr<IDBCursorBackend> prpBackend) { LOG(StorageAPI, "IDBRequest::onSuccess(IDBCursor)"); if (!shouldEnqueueEvent()) return; DOMRequestState::Scope scope(m_requestState); RefPtr<IDBCursorBackend> backend = prpBackend; RefPtr<IDBKey> key = backend->key(); RefPtr<IDBKey> primaryKey = backend->primaryKey(); Deprecated::ScriptValue value = deserializeIDBValueBuffer(requestState(), backend->valueBuffer(), !!key); ASSERT(!m_pendingCursor); RefPtr<IDBCursor> cursor; switch (m_cursorType) { case IndexedDB::CursorType::KeyOnly: cursor = IDBCursor::create(backend.release(), m_cursorDirection, this, m_source.get(), m_transaction.get()); break; case IndexedDB::CursorType::KeyAndValue: cursor = IDBCursorWithValue::create(backend.release(), m_cursorDirection, this, m_source.get(), m_transaction.get()); break; default: ASSERT_NOT_REACHED(); } setResultCursor(cursor, key.release(), primaryKey.release(), value); enqueueEvent(createSuccessEvent()); }
void IDBOpenDBRequest::onUpgradeNeeded(int64_t oldVersion, PassOwnPtr<WebIDBDatabase> backend, const IDBDatabaseMetadata& metadata, WebIDBDataLoss dataLoss, String dataLossMessage) { IDB_TRACE("IDBOpenDBRequest::onUpgradeNeeded()"); if (m_contextStopped || !executionContext()) { OwnPtr<WebIDBDatabase> db = backend; db->abort(m_transactionId); db->close(); return; } if (!shouldEnqueueEvent()) return; ASSERT(m_databaseCallbacks); IDBDatabase* idbDatabase = IDBDatabase::create(executionContext(), backend, m_databaseCallbacks.release()); idbDatabase->setMetadata(metadata); if (oldVersion == IDBDatabaseMetadata::NoIntVersion) { // This database hasn't had an integer version before. oldVersion = IDBDatabaseMetadata::DefaultIntVersion; } IDBDatabaseMetadata oldMetadata(metadata); oldMetadata.intVersion = oldVersion; m_transaction = IDBTransaction::create(scriptState(), m_transactionId, idbDatabase, this, oldMetadata); setResult(IDBAny::create(idbDatabase)); if (m_version == IDBDatabaseMetadata::NoIntVersion) m_version = 1; enqueueEvent(IDBVersionChangeEvent::create(EventTypeNames::upgradeneeded, oldVersion, m_version, dataLoss, dataLossMessage)); }
void IDBOpenDBRequest::onSuccess(PassOwnPtr<WebIDBDatabase> backend, const IDBDatabaseMetadata& metadata) { IDB_TRACE("IDBOpenDBRequest::onSuccess()"); if (m_contextStopped || !executionContext()) { OwnPtr<WebIDBDatabase> db = backend; if (db) db->close(); return; } if (!shouldEnqueueEvent()) return; IDBDatabase* idbDatabase = nullptr; if (resultAsAny()) { // Previous onUpgradeNeeded call delivered the backend. ASSERT(!backend.get()); idbDatabase = resultAsAny()->idbDatabase(); ASSERT(idbDatabase); ASSERT(!m_databaseCallbacks); } else { ASSERT(backend.get()); ASSERT(m_databaseCallbacks); idbDatabase = IDBDatabase::create(executionContext(), backend, m_databaseCallbacks.release()); setResult(IDBAny::create(idbDatabase)); } idbDatabase->setMetadata(metadata); enqueueEvent(Event::create(EventTypeNames::success)); }
void IDBTransaction::onAbort(DOMException* error) { IDB_TRACE("IDBTransaction::onAbort"); if (!getExecutionContext()) { finished(); return; } DCHECK_NE(m_state, Finished); if (m_state != Finishing) { // Abort was not triggered by front-end. DCHECK(error); setError(error); abortOutstandingRequests(); revertDatabaseMetadata(); m_state = Finishing; } if (isVersionChange()) m_database->close(); // Enqueue events before notifying database, as database may close which // enqueues more events and order matters. enqueueEvent(Event::createBubble(EventTypeNames::abort)); finished(); }
void IDBOpenDBRequest::onError(const IDBResultData& data) { ASSERT(currentThread() == originThreadID()); m_domError = DOMError::create(data.error().name(), data.error().message()); enqueueEvent(IDBRequestCompletionEvent::create(eventNames().errorEvent, true, true, *this)); }
void IDBOpenDBRequest::requestBlocked(uint64_t oldVersion, uint64_t newVersion) { ASSERT(currentThread() == originThreadID()); LOG(IndexedDB, "IDBOpenDBRequest::requestBlocked"); enqueueEvent(IDBVersionChangeEvent::create(oldVersion, newVersion, eventNames().blockedEvent)); }
void LegacyTransaction::onAbort(PassRefPtr<IDBDatabaseError> prpError) { LOG(StorageAPI, "LegacyTransaction::onAbort"); RefPtr<IDBDatabaseError> error = prpError; ASSERT(m_state != Finished); if (m_state != Finishing) { ASSERT(error.get()); setError(DOMError::create(error->name()), error->message()); // Abort was not triggered by front-end, so outstanding requests must // be aborted now. while (!m_requestList.isEmpty()) { RefPtr<LegacyRequest> request = *m_requestList.begin(); m_requestList.remove(request); request->abort(); } m_state = Finishing; } if (isVersionChange()) { for (auto& objectStore : m_objectStoreCleanupMap) objectStore.key->setMetadata(objectStore.value); m_database->setMetadata(m_previousMetadata); m_database->close(); } m_objectStoreCleanupMap.clear(); closeOpenCursors(); // Enqueue events before notifying database, as database may close which enqueues more events and order matters. enqueueEvent(Event::create(eventNames().abortEvent, true, false)); m_database->transactionFinished(this); }
void GameState::enqueueInsert(Entity *ptr) { DelayedEvent event; event.type = EVENT_INSERT; event.map = 0; enqueueEvent(ptr, event); }
void IDBRequest::onError(PassRefPtr<IDBDatabaseError> error) { ASSERT(!m_errorCode && m_errorMessage.isNull() && !m_result); m_errorCode = error->code(); m_errorMessage = error->message(); enqueueEvent(Event::create(eventNames().errorEvent, true, true)); }
void IDBRequest::onSuccess(PassRefPtr<IDBCursorBackendInterface> backend, PassRefPtr<IDBKey> key, PassRefPtr<IDBKey> primaryKey, PassRefPtr<SerializedScriptValue> serializedValue) { IDB_TRACE("IDBRequest::onSuccess(IDBCursor)"); 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 ScriptValue value = deserializeIDBValue(scriptExecutionContext(), serializedValue); ASSERT(m_cursorType != IDBCursorBackendInterface::InvalidCursorType); RefPtr<IDBCursor> cursor; if (m_cursorType == IDBCursorBackendInterface::IndexKeyCursor) cursor = IDBCursor::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get()); else cursor = IDBCursorWithValue::create(backend, m_cursorDirection, this, m_source.get(), m_transaction.get()); setResultCursor(cursor, key, primaryKey, value); enqueueEvent(createSuccessEvent()); }
void IDBDatabase::forceClose() { for (const auto& it : m_transactions) it.value->abort(IGNORE_EXCEPTION); this->close(); enqueueEvent(Event::create(EventTypeNames::close)); }
void IDBDatabase::forceClose() { for (TransactionMap::const_iterator::Values it = m_transactions.begin().values(), end = m_transactions.end().values(); it != end; ++it) (*it)->abort(IGNORE_EXCEPTION); this->close(); enqueueEvent(Event::create(EventTypeNames::close)); }
void IDBRequest::onError() { LOG(IndexedDB, "IDBRequest::onError"); ASSERT(!m_idbError.isNull()); m_domError = DOMError::create(m_idbError.name()); enqueueEvent(Event::create(eventNames().errorEvent, true, true)); }
void IDBOpenDBRequest::onBlocked(int64_t oldVersion) { IDB_TRACE("IDBOpenDBRequest::onBlocked()"); if (!shouldEnqueueEvent()) return; Nullable<unsigned long long> newVersionNullable = (m_version == IDBDatabaseMetadata::DefaultIntVersion) ? Nullable<unsigned long long>() : Nullable<unsigned long long>(m_version); enqueueEvent(IDBVersionChangeEvent::create(EventTypeNames::blocked, oldVersion, newVersionNullable)); }
void KviSensitiveThread::terminate() { //qDebug("Entering KviSensitiveThread::terminate (this=%d)",this); enqueueEvent(new KviThreadEvent(KVI_THREAD_EVENT_TERMINATE)); //qDebug("KviSensitiveThread::terminate() : event enqueued waiting (this=%d)",this); wait(); //qDebug("Exiting KviSensitiveThread::terminate (this=%d)",this); }
void IDBRequest::onSuccessInternal(const ScriptValue& value) { m_result = IDBAny::create(value); if (m_pendingCursor) { m_pendingCursor->close(); m_pendingCursor.clear(); } enqueueEvent(createSuccessEvent()); }
void IDBRequest::onSuccess(PassRefPtr<IDBDatabaseBackendInterface> backend) { ASSERT(!m_errorCode && m_errorMessage.isNull() && !m_result); RefPtr<IDBDatabase> idbDatabase = IDBDatabase::create(scriptExecutionContext(), backend); idbDatabase->open(); m_result = IDBAny::create(idbDatabase.release()); enqueueEvent(createSuccessEvent()); }
void LegacyRequest::onSuccessInternal(const Deprecated::ScriptValue& value) { m_result = LegacyAny::create(value); if (m_pendingCursor) { m_pendingCursor->close(); m_pendingCursor = nullptr; } enqueueEvent(createSuccessEvent()); }
void LegacyRequest::onSuccess(PassRefPtr<DOMStringList> domStringList) { LOG(StorageAPI, "LegacyRequest::onSuccess(DOMStringList)"); if (!shouldEnqueueEvent()) return; m_result = LegacyAny::create(domStringList); enqueueEvent(createSuccessEvent()); }
void IDBRequest::onSuccess(PassRefPtr<DOMStringList> domStringList) { IDB_TRACE("IDBRequest::onSuccess(DOMStringList)"); if (!shouldEnqueueEvent()) return; m_result = IDBAny::create(domStringList); enqueueEvent(createSuccessEvent()); }
void IDBDatabase::onVersionChange(const String& version) { if (m_contextStopped || !scriptExecutionContext()) return; if (m_closePending) return; enqueueEvent(IDBVersionChangeEvent::create(version, eventNames().versionchangeEvent)); }
void IDBRequest::onSuccess(PassRefPtr<IDBCursorBackendInterface> backend) { ASSERT(!m_errorCode && m_errorMessage.isNull() && !m_result); ASSERT(m_cursorType != IDBCursorBackendInterface::InvalidCursorType); if (m_cursorType == IDBCursorBackendInterface::IndexKeyCursor) m_result = IDBAny::create(IDBCursor::create(backend, this, m_source.get(), m_transaction.get())); else m_result = IDBAny::create(IDBCursorWithValue::create(backend, this, m_source.get(), m_transaction.get())); enqueueEvent(createSuccessEvent()); }
void IDBRequest::onError(PassRefPtr<DOMError> error) { IDB_TRACE("IDBRequest::onError()"); if (!shouldEnqueueEvent()) return; m_error = error; m_pendingCursor.clear(); enqueueEvent(Event::createCancelableBubble(EventTypeNames::error)); }