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));
}
Beispiel #4
0
 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);
         }
     }
 }
Beispiel #5
0
void GameState::enqueueRemove(Entity *ptr)
{
    DelayedEvent event;
    event.type = EVENT_REMOVE;
    event.map = 0;
    enqueueEvent(ptr, event);
}
Beispiel #6
0
void IDBRequest::onSuccessInternal(PassRefPtr<IDBAny> result)
{
    ASSERT(!m_contextStopped);
    ASSERT(!m_pendingCursor);
    setResult(result);
    enqueueEvent(Event::create(EventTypeNames::success));
}
Beispiel #7
0
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));
}
Beispiel #8
0
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));
}
Beispiel #11
0
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));
}
Beispiel #14
0
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);
}
Beispiel #15
0
void GameState::enqueueInsert(Entity *ptr)
{
    DelayedEvent event;
    event.type = EVENT_INSERT;
    event.map = 0;
    enqueueEvent(ptr, event);
}
Beispiel #16
0
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));
}
Beispiel #17
0
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));
}
Beispiel #19
0
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));
}
Beispiel #20
0
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));
}
Beispiel #22
0
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);
}
Beispiel #23
0
void IDBRequest::onSuccessInternal(const ScriptValue& value)
{
    m_result = IDBAny::create(value);
    if (m_pendingCursor) {
        m_pendingCursor->close();
        m_pendingCursor.clear();
    }
    enqueueEvent(createSuccessEvent());
}
Beispiel #24
0
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());
}
Beispiel #25
0
void LegacyRequest::onSuccessInternal(const Deprecated::ScriptValue& value)
{
    m_result = LegacyAny::create(value);
    if (m_pendingCursor) {
        m_pendingCursor->close();
        m_pendingCursor = nullptr;
    }
    enqueueEvent(createSuccessEvent());
}
Beispiel #26
0
void LegacyRequest::onSuccess(PassRefPtr<DOMStringList> domStringList)
{
    LOG(StorageAPI, "LegacyRequest::onSuccess(DOMStringList)");
    if (!shouldEnqueueEvent())
        return;

    m_result = LegacyAny::create(domStringList);
    enqueueEvent(createSuccessEvent());
}
Beispiel #27
0
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));
}
Beispiel #29
0
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());
}
Beispiel #30
0
void IDBRequest::onError(PassRefPtr<DOMError> error)
{
    IDB_TRACE("IDBRequest::onError()");
    if (!shouldEnqueueEvent())
        return;

    m_error = error;
    m_pendingCursor.clear();
    enqueueEvent(Event::createCancelableBubble(EventTypeNames::error));
}