C++ scheduleDispatchEvent函数代码示例

void MediaStream::setStreamIsActive(bool streamActive)
{
    if (streamActive)
        scheduleDispatchEvent(Event::create(eventNames().activeEvent, false, false));
    else
        scheduleDispatchEvent(Event::create(eventNames().inactiveEvent, false, false));
}

void RTCPeerConnection::didGenerateICECandidate(const blink::WebRTCICECandidate& webCandidate)
{
    ASSERT(executionContext()->isContextThread());
    if (webCandidate.isNull())
        scheduleDispatchEvent(RTCIceCandidateEvent::create(false, false, nullptr));
    else {
        RefPtr<RTCIceCandidate> iceCandidate = RTCIceCandidate::create(webCandidate);
        scheduleDispatchEvent(RTCIceCandidateEvent::create(false, false, iceCandidate.release()));
    }
}

void MediaStream::streamEnded()
{
    if (m_stopped || m_descriptor->ended())
        return;

    if (active()) {
        m_descriptor->setActive(false);
        scheduleDispatchEvent(Event::create(EventTypeNames::inactive));
    }
    m_descriptor->setEnded();
    scheduleDispatchEvent(Event::create(EventTypeNames::ended));
}

void RTCDataChannel::didDecreaseBufferedAmount(unsigned previousAmount)
{
    if (previousAmount > m_bufferedAmountLowThreshold
        && bufferedAmount() <= m_bufferedAmountLowThreshold) {
        scheduleDispatchEvent(Event::create(EventTypeNames::bufferedamountlow));
    }
}

void MediaStream::addRemoteTrack(MediaStreamTrackPrivate* privateTrack)
{
    ASSERT(privateTrack);
    if (!active())
        return;

    RefPtr<MediaStreamTrack> track;
    switch (privateTrack->type()) {
    case RealtimeMediaSource::Audio:
        track = AudioStreamTrack::create(*scriptExecutionContext(), *privateTrack);
        break;
    case RealtimeMediaSource::Video:
        track = VideoStreamTrack::create(*scriptExecutionContext(), *privateTrack);
        break;
    case RealtimeMediaSource::None:
        ASSERT_NOT_REACHED();
        break;
    }

    if (!track)
        return;

    if (addTrack(track))
        scheduleDispatchEvent(MediaStreamTrackEvent::create(eventNames().addtrackEvent, false, false, track));
}

void MediaStream::removeRemoteSource(MediaStreamSource* source)
{
    if (ended())
        return;

    MediaStreamTrackVector* tracks = 0;
    switch (source->type()) {
    case MediaStreamSource::Audio:
        tracks = &m_audioTracks;
        break;
    case MediaStreamSource::Video:
        tracks = &m_videoTracks;
        break;
    }

    size_t index = notFound;
    for (size_t i = 0; i < tracks->size(); ++i) {
        if ((*tracks)[i]->source() == source) {
            index = i;
            break;
        }
    }
    if (index == notFound)
        return;

    m_descriptor->removeSource(source);

    RefPtr<MediaStreamTrack> track = (*tracks)[index];
    tracks->remove(index);
    scheduleDispatchEvent(MediaStreamTrackEvent::create(eventNames().removetrackEvent, false, false, track));
}

void RTCPeerConnection::changeSignalingState(SignalingState signalingState)
{
    if (m_signalingState != SignalingStateClosed && m_signalingState != signalingState) {
        m_signalingState = signalingState;
        scheduleDispatchEvent(Event::create(EventTypeNames::signalingstatechange));
    }
}

void RTCDataChannel::didReceiveStringData(const String& text)
{
    if (m_stopped)
        return;

    scheduleDispatchEvent(MessageEvent::create(text));
}

void RTCPeerConnection::changeIceGatheringState(IceGatheringState iceGatheringState)
{
    if (m_iceGatheringState != iceGatheringState) {
        m_iceGatheringState = iceGatheringState;
        scheduleDispatchEvent(Event::create(eventNames().gatheringchangeEvent, false, false));
    }
}

void RTCDataChannel::didDetectError()
{
    if (m_stopped)
        return;

    scheduleDispatchEvent(Event::create(EventTypeNames::error));
}

void MediaStream::removeRemoteTrack(MediaStreamComponent* component)
{
    if (ended())
        return;

    MediaStreamTrackVector* tracks = 0;
    switch (component->source()->type()) {
    case MediaStreamSource::TypeAudio:
        tracks = &m_audioTracks;
        break;
    case MediaStreamSource::TypeVideo:
        tracks = &m_videoTracks;
        break;
    }

    size_t index = notFound;
    for (size_t i = 0; i < tracks->size(); ++i) {
        if ((*tracks)[i]->component() == component) {
            index = i;
            break;
        }
    }
    if (index == notFound)
        return;

    RefPtr<MediaStreamTrack> track = (*tracks)[index];
    tracks->remove(index);
    scheduleDispatchEvent(MediaStreamTrackEvent::create(eventNames().removetrackEvent, false, false, track));
}

void MediaStream::streamDidEnd()
{
    if (ended())
        return;

    scheduleDispatchEvent(Event::create(eventNames().endedEvent, false, false));
}

void MediaRecorder::writeData(const char* data,
                              size_t length,
                              bool lastInSlice) {
  if (m_stopped && !lastInSlice) {
    m_stopped = false;
    scheduleDispatchEvent(Event::create(EventTypeNames::start));
  }
  if (m_stream && m_streamAmountOfTracks != m_stream->getTracks().size()) {
    m_streamAmountOfTracks = m_stream->getTracks().size();
    onError("Amount of tracks in MediaStream has changed.");
  }

  // TODO(mcasas): Act as |m_ignoredMutedMedia| instructs if |m_stream| track(s)
  // is in muted() state.

  if (!m_blobData) {
    m_blobData = BlobData::create();
    m_blobData->setContentType(m_mimeType);
  }
  if (data)
    m_blobData->appendBytes(data, length);

  if (!lastInSlice)
    return;

  // Cache |m_blobData->length()| before release()ng it.
  const long long blobDataLength = m_blobData->length();
  createBlobEvent(Blob::create(
      BlobDataHandle::create(std::move(m_blobData), blobDataLength)));
}

void MediaStream::streamEnded()
{
    if (ended())
        return;

    m_descriptor->setEnded();
    scheduleDispatchEvent(Event::create(eventNames().endedEvent, false, false));
}

void MediaStream::streamEnded()
{
    if (ended())
        return;

    m_descriptor->setEnded();
    scheduleDispatchEvent(Event::create(EventTypeNames::ended));
}