C++ (Cpp) ToV8UndefinedGenerator Examples

Example #1

File: ReadableStream.cpp Project: kjthegod/WebKit

void ReadableStream::close()
{
    if (m_state == Waiting) {
        m_ready->resolve(ToV8UndefinedGenerator());
        m_closed->resolve(ToV8UndefinedGenerator());
        m_state = Closed;
    } else if (m_state == Readable) {
        m_isDraining = true;
    }
}

Example #2

File: ReadableStream.cpp Project: kjthegod/WebKit

ScriptPromise ReadableStream::cancel(ScriptState* scriptState, ScriptValue reason)
{
    if (m_state == Closed)
        return ScriptPromise::cast(scriptState, v8::Undefined(scriptState->isolate()));
    if (m_state == Errored)
        return ScriptPromise::rejectWithDOMException(scriptState, m_exception);

    ASSERT(m_state == Readable || m_state == Waiting);
    if (m_state == Waiting)
        m_ready->resolve(ToV8UndefinedGenerator());
    clearQueue();
    m_closed->resolve(ToV8UndefinedGenerator());
    m_state = Closed;
    return m_source->cancelSource(scriptState, reason).then(ConstUndefined::create(scriptState));
}

Example #3

File: ReadableStreamReader.cpp Project: dstockwell/blink

void ReadableStreamReader::releaseLock()
{
    if (!isActive())
        return;

    ASSERT(!m_stream->hasPendingReads());
    if (m_stream->stateInternal() == ReadableStream::Closed) {
        m_stateAfterRelease = ReadableStream::Closed;
        m_closed->resolve(ToV8UndefinedGenerator());
    } else if (m_stream->stateInternal() == ReadableStream::Errored) {
        m_stateAfterRelease = ReadableStream::Errored;
        m_closed->reject(m_stream->storedException());
    } else {
        m_stateAfterRelease = ReadableStream::Closed;
        m_closed->resolve(ToV8UndefinedGenerator());
    }

    // We call setReader(nullptr) after resolving / rejecting |m_closed|
    // because it affects hasPendingActivity.
    m_stream->setReader(nullptr);
    ASSERT(!isActive());
}

Example #4

File: ReadableStream.cpp Project: kjthegod/WebKit

void ReadableStream::readPostAction()
{
    ASSERT(m_state == Readable);
    if (isQueueEmpty()) {
        if (m_isDraining) {
            m_closed->resolve(ToV8UndefinedGenerator());
            m_state = Closed;
        } else {
            m_ready->reset();
            m_state = Waiting;
        }
    }
    callPullIfNeeded();
}

Example #5

File: ReadableStreamReader.cpp Project: aobzhirov/ChromiumGStreamerBackend

ReadableStreamReader::ReadableStreamReader(ExecutionContext* executionContext, ReadableStream* stream)
    : ActiveScriptWrappable(this)
    , ActiveDOMObject(executionContext)
    , m_stream(stream)
    , m_closed(new ClosedPromise(executionContext, this, ClosedPromise::Closed))
{
    suspendIfNeeded();
    ASSERT(m_stream->isLockedTo(nullptr));
    m_stream->setReader(this);

    if (m_stream->stateInternal() == ReadableStream::Closed)
        m_closed->resolve(ToV8UndefinedGenerator());
    if (m_stream->stateInternal() == ReadableStream::Errored)
        m_closed->reject(m_stream->storedException());
}

Example #6

File: MediaKeySession.cpp Project: astojilj/chromium-crosswalk

void MediaKeySession::close()
{
    WTF_LOG(Media, "MediaKeySession(%p)::close", this);

    // From https://w3c.github.io/encrypted-media/#session-close:
    // The following steps are run:
    // 1. Let the session be the associated MediaKeySession object.
    // 2. Let promise be the closed attribute of the session.
    // 3. Resolve promise.
    m_closedPromise->resolve(ToV8UndefinedGenerator());

    // Once closed, the session can no longer be the target of events from
    // the CDM so this object can be garbage collected.
    m_isClosed = true;
}

Example #7

File: ReadableStream.cpp Project: kjthegod/WebKit

bool ReadableStream::enqueuePostAction()
{
    m_isPulling = false;

    bool shouldApplyBackpressure = this->shouldApplyBackpressure();
    // this->shouldApplyBackpressure may call this->error().
    if (m_state == Errored)
        return false;

    if (m_state == Waiting) {
        // ReadableStream::hasPendingActivity return value gets false when
        // |m_state| is changed to Closed or Errored from Waiting or Readable.
        // On the other hand, the wrappers should be kept alive when |m_ready|
        // and |m_close| resolution and rejection are called. Hence we call
        // ScriptPromiseProperty::resolve and ScriptPromiseProperty::reject
        // *before* changing state, no matter if the state change actually
        // changes hasPendingActivity return value.
        m_ready->resolve(ToV8UndefinedGenerator());
        m_state = Readable;
    }

    return !shouldApplyBackpressure;
}

Example #8

File: ReadableStreamReader.cpp Project: aobzhirov/ChromiumGStreamerBackend

void ReadableStreamReader::close()
{
    ASSERT(isActive());
    m_closed->resolve(ToV8UndefinedGenerator());
}