void MediaStream::setStreamIsActive(bool streamActive)
{
if (streamActive)
scheduleDispatchEvent(Event::create(eventNames().activeEvent, false, false));
else
scheduleDispatchEvent(Event::create(eventNames().inactiveEvent, false, false));
}
void MediaStream::addRemoteTrack(MediaStreamComponent* component) {
DCHECK(component);
if (m_executionContext->isContextDestroyed())
return;
MediaStreamTrack* track =
MediaStreamTrack::create(m_executionContext, component);
switch (component->source()->type()) {
case MediaStreamSource::TypeAudio:
m_audioTracks.append(track);
break;
case MediaStreamSource::TypeVideo:
m_videoTracks.append(track);
break;
}
track->registerMediaStream(this);
m_descriptor->addComponent(component);
scheduleDispatchEvent(
MediaStreamTrackEvent::create(EventTypeNames::addtrack, track));
if (!active() && !track->ended()) {
m_descriptor->setActive(true);
scheduleDispatchEvent(Event::create(EventTypeNames::active));
}
}
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 RTCPeerConnection::didGenerateIceCandidate(PassRefPtr<RTCIceCandidateDescriptor> iceCandidateDescriptor)
{
ASSERT(scriptExecutionContext()->isContextThread());
if (!iceCandidateDescriptor)
scheduleDispatchEvent(RTCIceCandidateEvent::create(false, false, 0));
else {
RefPtr<RTCIceCandidate> iceCandidate = RTCIceCandidate::create(iceCandidateDescriptor);
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 MediaDevices::didChangeMediaDevices() {
Document* document = toDocument(getExecutionContext());
DCHECK(document);
if (RuntimeEnabledFeatures::onDeviceChangeEnabled())
scheduleDispatchEvent(Event::create(EventTypeNames::devicechange));
}
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 RTCPeerConnection::changeIceConnectionState(ICEConnectionState iceConnectionState)
{
if (m_iceConnectionState != ICEConnectionStateClosed && m_iceConnectionState != iceConnectionState) {
m_iceConnectionState = iceConnectionState;
scheduleDispatchEvent(Event::create(EventTypeNames::iceconnectionstatechange));
}
}
void MediaStream::removeTrack(MediaStreamTrack* track,
ExceptionState& exceptionState) {
if (!track) {
exceptionState.throwDOMException(
TypeMismatchError, "The MediaStreamTrack provided is invalid.");
return;
}
size_t pos = kNotFound;
switch (track->component()->source()->type()) {
case MediaStreamSource::TypeAudio:
pos = m_audioTracks.find(track);
if (pos != kNotFound)
m_audioTracks.remove(pos);
break;
case MediaStreamSource::TypeVideo:
pos = m_videoTracks.find(track);
if (pos != kNotFound)
m_videoTracks.remove(pos);
break;
}
if (pos == kNotFound)
return;
track->unregisterMediaStream(this);
m_descriptor->removeComponent(track->component());
if (active() && emptyOrOnlyEndedTracks()) {
m_descriptor->setActive(false);
scheduleDispatchEvent(Event::create(EventTypeNames::inactive));
}
MediaStreamCenter::instance().didRemoveMediaStreamTrack(m_descriptor,
track->component());
}
void MediaStream::addTrack(MediaStreamTrack* track,
ExceptionState& exceptionState) {
if (!track) {
exceptionState.throwDOMException(
TypeMismatchError, "The MediaStreamTrack provided is invalid.");
return;
}
if (getTrackById(track->id()))
return;
switch (track->component()->source()->type()) {
case MediaStreamSource::TypeAudio:
m_audioTracks.append(track);
break;
case MediaStreamSource::TypeVideo:
m_videoTracks.append(track);
break;
}
track->registerMediaStream(this);
m_descriptor->addComponent(track->component());
if (!active() && !track->ended()) {
m_descriptor->setActive(true);
scheduleDispatchEvent(Event::create(EventTypeNames::active));
}
MediaStreamCenter::instance().didAddMediaStreamTrack(m_descriptor,
track->component());
}
void RTCPeerConnection::changeIceConnectionState(IceConnectionState iceConnectionState)
{
if (m_iceConnectionState != IceConnectionStateClosed && m_iceConnectionState != iceConnectionState) {
m_iceConnectionState = iceConnectionState;
scheduleDispatchEvent(Event::create(eventNames().iceconnectionstatechangeEvent, false, false));
}
}
void RTCDataChannel::didReceiveStringData(const String& text)
{
if (m_stopped)
return;
scheduleDispatchEvent(MessageEvent::create(text));
}
void RTCDataChannel::didDetectError()
{
if (m_stopped)
return;
scheduleDispatchEvent(Event::create(eventNames().errorEvent, false, false));
}
void RTCPeerConnection::changeIceGatheringState(IceGatheringState iceGatheringState)
{
if (m_iceGatheringState != iceGatheringState) {
m_iceGatheringState = iceGatheringState;
scheduleDispatchEvent(Event::create(eventNames().gatheringchangeEvent, false, false));
}
}
void RTCPeerConnection::changeSignalingState(SignalingState signalingState)
{
if (m_signalingState != SignalingStateClosed && m_signalingState != signalingState) {
m_signalingState = signalingState;
scheduleDispatchEvent(Event::create(eventNames().signalingstatechangeEvent, 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 MediaStream::addTrack(PassRefPtr<MediaStreamTrack> prpTrack, ExceptionCode& ec)
{
if (ended()) {
ec = INVALID_STATE_ERR;
return;
}
if (!prpTrack) {
ec = TYPE_MISMATCH_ERR;
return;
}
RefPtr<MediaStreamTrack> track = prpTrack;
if (getTrackById(track->id()))
return;
RefPtr<MediaStreamComponent> component = MediaStreamComponent::create(m_descriptor.get(), track->component()->source());
RefPtr<MediaStreamTrack> newTrack = MediaStreamTrack::create(scriptExecutionContext(), component.get());
switch (component->source()->type()) {
case MediaStreamSource::TypeAudio:
m_descriptor->addAudioComponent(component.release());
m_audioTracks.append(newTrack);
break;
case MediaStreamSource::TypeVideo:
m_descriptor->addVideoComponent(component.release());
m_videoTracks.append(newTrack);
break;
}
MediaStreamCenter::instance().didAddMediaStreamTrack(m_descriptor.get(), newTrack->component());
scheduleDispatchEvent(MediaStreamTrackEvent::create(eventNames().addtrackEvent, false, false, newTrack.release()));
}
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 RTCPeerConnection::changeReadyState(ReadyState readyState)
{
if (readyState == ReadyStateNew) {
ASSERT_NOT_REACHED();
return;
}
if (readyState == m_readyState || m_readyState == ReadyStateClosed)
return;
m_readyState = readyState;
if (m_readyState == ReadyStateActive)
scheduleDispatchEvent(Event::create(eventNames().openEvent, false, false));
scheduleDispatchEvent(Event::create(eventNames().statechangeEvent, false, false));
}
void RTCPeerConnection::changeIceState(IceState iceState)
{
if (iceState == m_iceState || m_readyState == ReadyStateClosed)
return;
m_iceState = iceState;
scheduleDispatchEvent(Event::create(eventNames().icechangeEvent, false, false));
}
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));
}
void RTCDataChannel::didChangeReadyState(ReadyState newState)
{
if (m_stopped || m_readyState == ReadyStateClosed || m_readyState == newState)
return;
m_readyState = newState;
switch (m_readyState) {
case ReadyStateOpen:
scheduleDispatchEvent(Event::create(eventNames().openEvent, false, false));
break;
case ReadyStateClosed:
scheduleDispatchEvent(Event::create(eventNames().closeEvent, false, false));
break;
default:
break;
}
}
void RTCDataChannel::didChangeReadyState(blink::WebRTCDataChannelHandlerClient::ReadyState newState)
{
if (m_stopped || m_readyState == ReadyStateClosed)
return;
m_readyState = newState;
switch (m_readyState) {
case ReadyStateOpen:
scheduleDispatchEvent(Event::create(EventTypeNames::open));
break;
case ReadyStateClosed:
scheduleDispatchEvent(Event::create(EventTypeNames::close));
break;
default:
break;
}
}
void MediaStream::streamEnded() {
if (m_executionContext->isContextDestroyed())
return;
if (active()) {
m_descriptor->setActive(false);
scheduleDispatchEvent(Event::create(EventTypeNames::inactive));
}
}
