script/dom/webrtc/
rtcpeerconnection.rs

1/* This Source Code Form is subject to the terms of the Mozilla Public
2 * License, v. 2.0. If a copy of the MPL was not distributed with this
3 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
4
5use std::cell::Cell;
6use std::rc::Rc;
7
8use dom_struct::dom_struct;
9use js::context::JSContext;
10use js::realm::CurrentRealm;
11use js::rust::HandleObject;
12use rustc_hash::FxHashMap;
13use script_bindings::cell::DomRefCell;
14use script_bindings::reflector::reflect_dom_object_with_proto;
15use servo_media::ServoMedia;
16use servo_media::streams::MediaStreamType;
17use servo_media::streams::registry::MediaStreamId;
18use servo_media::webrtc::{
19    BundlePolicy, DataChannelEvent, DataChannelId, DataChannelState, GatheringState, IceCandidate,
20    IceConnectionState, SdpType, SessionDescription, SignalingState, WebRtcController,
21    WebRtcSignaller,
22};
23
24use crate::conversions::Convert;
25use crate::dom::bindings::codegen::Bindings::RTCDataChannelBinding::RTCDataChannelInit;
26use crate::dom::bindings::codegen::Bindings::RTCIceCandidateBinding::RTCIceCandidateInit;
27use crate::dom::bindings::codegen::Bindings::RTCPeerConnectionBinding::{
28    RTCAnswerOptions, RTCBundlePolicy, RTCConfiguration, RTCIceConnectionState,
29    RTCIceGatheringState, RTCOfferOptions, RTCPeerConnectionMethods, RTCRtpTransceiverInit,
30    RTCSignalingState,
31};
32use crate::dom::bindings::codegen::Bindings::RTCSessionDescriptionBinding::{
33    RTCSdpType, RTCSessionDescriptionInit, RTCSessionDescriptionMethods,
34};
35use crate::dom::bindings::codegen::UnionTypes::{MediaStreamTrackOrString, StringOrStringSequence};
36use crate::dom::bindings::error::{Error, Fallible};
37use crate::dom::bindings::inheritance::Castable;
38use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
39use crate::dom::bindings::reflector::DomGlobal;
40use crate::dom::bindings::root::{Dom, DomRoot, MutNullableDom};
41use crate::dom::bindings::str::USVString;
42use crate::dom::event::{Event, EventBubbles, EventCancelable};
43use crate::dom::eventtarget::EventTarget;
44use crate::dom::mediastream::MediaStream;
45use crate::dom::mediastreamtrack::MediaStreamTrack;
46use crate::dom::promise::Promise;
47use crate::dom::rtcdatachannel::RTCDataChannel;
48use crate::dom::rtcdatachannelevent::RTCDataChannelEvent;
49use crate::dom::rtcicecandidate::RTCIceCandidate;
50use crate::dom::rtcpeerconnectioniceevent::RTCPeerConnectionIceEvent;
51use crate::dom::rtcrtptransceiver::RTCRtpTransceiver;
52use crate::dom::rtcsessiondescription::RTCSessionDescription;
53use crate::dom::rtctrackevent::RTCTrackEvent;
54use crate::dom::window::Window;
55use crate::realms::{InRealm, enter_auto_realm};
56use crate::script_runtime::CanGc;
57use crate::task_source::SendableTaskSource;
58
59#[dom_struct]
60pub(crate) struct RTCPeerConnection {
61    eventtarget: EventTarget,
62    #[ignore_malloc_size_of = "defined in servo-media"]
63    #[no_trace]
64    controller: DomRefCell<Option<WebRtcController>>,
65    closed: Cell<bool>,
66    // Helps track state changes between the time createOffer/createAnswer
67    // is called and resolved
68    offer_answer_generation: Cell<u32>,
69    #[conditional_malloc_size_of]
70    offer_promises: DomRefCell<Vec<Rc<Promise>>>,
71    #[conditional_malloc_size_of]
72    answer_promises: DomRefCell<Vec<Rc<Promise>>>,
73    local_description: MutNullableDom<RTCSessionDescription>,
74    remote_description: MutNullableDom<RTCSessionDescription>,
75    gathering_state: Cell<RTCIceGatheringState>,
76    ice_connection_state: Cell<RTCIceConnectionState>,
77    signaling_state: Cell<RTCSignalingState>,
78    #[ignore_malloc_size_of = "defined in servo-media"]
79    data_channels: DomRefCell<FxHashMap<DataChannelId, Dom<RTCDataChannel>>>,
80}
81
82struct RTCSignaller {
83    trusted: Trusted<RTCPeerConnection>,
84    task_source: SendableTaskSource,
85}
86
87impl WebRtcSignaller for RTCSignaller {
88    fn on_ice_candidate(&self, _: &WebRtcController, candidate: IceCandidate) {
89        let this = self.trusted.clone();
90        self.task_source.queue(task!(on_ice_candidate: move |cx| {
91            let this = this.root();
92            this.on_ice_candidate(cx, candidate);
93        }));
94    }
95
96    fn on_negotiation_needed(&self, _: &WebRtcController) {
97        let this = self.trusted.clone();
98        self.task_source
99            .queue(task!(on_negotiation_needed: move |cx| {
100                let this = this.root();
101                this.on_negotiation_needed(cx);
102            }));
103    }
104
105    fn update_gathering_state(&self, state: GatheringState) {
106        let this = self.trusted.clone();
107        self.task_source
108            .queue(task!(update_gathering_state: move |cx| {
109                let this = this.root();
110                this.update_gathering_state(cx, state);
111            }));
112    }
113
114    fn update_ice_connection_state(&self, state: IceConnectionState) {
115        let this = self.trusted.clone();
116        self.task_source
117            .queue(task!(update_ice_connection_state: move |cx| {
118                let this = this.root();
119                this.update_ice_connection_state(cx, state);
120            }));
121    }
122
123    fn update_signaling_state(&self, state: SignalingState) {
124        let this = self.trusted.clone();
125        self.task_source
126            .queue(task!(update_signaling_state: move |cx| {
127                let this = this.root();
128                this.update_signaling_state(cx, state);
129            }));
130    }
131
132    fn on_add_stream(&self, id: &MediaStreamId, ty: MediaStreamType) {
133        let this = self.trusted.clone();
134        let id = *id;
135        self.task_source.queue(task!(on_add_stream: move |cx| {
136            let this = this.root();
137            this.on_add_stream(cx, id, ty, );
138        }));
139    }
140
141    fn on_data_channel_event(
142        &self,
143        channel: DataChannelId,
144        event: DataChannelEvent,
145        _: &WebRtcController,
146    ) {
147        // XXX(ferjm) get label and options from channel properties.
148        let this = self.trusted.clone();
149        self.task_source
150            .queue(task!(on_data_channel_event: move |cx| {
151                let this = this.root();
152                let global = this.global();
153                let mut realm = enter_auto_realm(cx, &*global);
154                this.on_data_channel_event(&mut realm.current_realm(), channel, event);
155            }));
156    }
157
158    fn close(&self) {
159        // do nothing
160    }
161}
162
163impl RTCPeerConnection {
164    pub(crate) fn new_inherited() -> RTCPeerConnection {
165        RTCPeerConnection {
166            eventtarget: EventTarget::new_inherited(),
167            controller: DomRefCell::new(None),
168            closed: Cell::new(false),
169            offer_answer_generation: Cell::new(0),
170            offer_promises: DomRefCell::new(vec![]),
171            answer_promises: DomRefCell::new(vec![]),
172            local_description: Default::default(),
173            remote_description: Default::default(),
174            gathering_state: Cell::new(RTCIceGatheringState::New),
175            ice_connection_state: Cell::new(RTCIceConnectionState::New),
176            signaling_state: Cell::new(RTCSignalingState::Stable),
177            data_channels: DomRefCell::new(FxHashMap::default()),
178        }
179    }
180
181    fn new(
182        window: &Window,
183        proto: Option<HandleObject>,
184        config: &RTCConfiguration,
185        can_gc: CanGc,
186    ) -> DomRoot<RTCPeerConnection> {
187        let this = reflect_dom_object_with_proto(
188            Box::new(RTCPeerConnection::new_inherited()),
189            window,
190            proto,
191            can_gc,
192        );
193        let signaller = this.make_signaller();
194        *this.controller.borrow_mut() = Some(ServoMedia::get().create_webrtc(signaller));
195        if let Some(ref servers) = config.iceServers &&
196            let Some(server) = servers.first()
197        {
198            let server = match server.urls {
199                StringOrStringSequence::String(ref s) => Some(s.clone()),
200                StringOrStringSequence::StringSequence(ref s) => s.first().cloned(),
201            };
202            if let Some(server) = server {
203                let policy = match config.bundlePolicy {
204                    RTCBundlePolicy::Balanced => BundlePolicy::Balanced,
205                    RTCBundlePolicy::Max_compat => BundlePolicy::MaxCompat,
206                    RTCBundlePolicy::Max_bundle => BundlePolicy::MaxBundle,
207                };
208                this.controller
209                    .borrow()
210                    .as_ref()
211                    .unwrap()
212                    .configure(String::from(server), policy);
213            }
214        }
215        this
216    }
217
218    pub(crate) fn get_webrtc_controller(&self) -> &DomRefCell<Option<WebRtcController>> {
219        &self.controller
220    }
221
222    fn make_signaller(&self) -> Box<dyn WebRtcSignaller> {
223        let trusted = Trusted::new(self);
224        Box::new(RTCSignaller {
225            trusted,
226            task_source: self.global().task_manager().networking_task_source().into(),
227        })
228    }
229
230    fn on_ice_candidate(&self, cx: &mut js::context::JSContext, candidate: IceCandidate) {
231        if self.closed.get() {
232            return;
233        }
234        let candidate = RTCIceCandidate::new(
235            self.global().as_window(),
236            candidate.candidate.into(),
237            None,
238            Some(candidate.sdp_mline_index as u16),
239            None,
240            CanGc::from_cx(cx),
241        );
242        let event = RTCPeerConnectionIceEvent::new(
243            self.global().as_window(),
244            atom!("icecandidate"),
245            Some(&candidate),
246            None,
247            true,
248            CanGc::from_cx(cx),
249        );
250        event.upcast::<Event>().fire(cx, self.upcast());
251    }
252
253    fn on_negotiation_needed(&self, cx: &mut js::context::JSContext) {
254        if self.closed.get() {
255            return;
256        }
257        let event = Event::new(
258            &self.global(),
259            atom!("negotiationneeded"),
260            EventBubbles::DoesNotBubble,
261            EventCancelable::NotCancelable,
262            CanGc::from_cx(cx),
263        );
264        event.upcast::<Event>().fire(cx, self.upcast());
265    }
266
267    fn on_add_stream(&self, cx: &mut JSContext, id: MediaStreamId, ty: MediaStreamType) {
268        if self.closed.get() {
269            return;
270        }
271        let track = MediaStreamTrack::new(cx, &self.global(), id, ty);
272        let event = RTCTrackEvent::new(
273            cx,
274            self.global().as_window(),
275            atom!("track"),
276            false,
277            false,
278            &track,
279        );
280        event.upcast::<Event>().fire(cx, self.upcast());
281    }
282
283    fn on_data_channel_event(
284        &self,
285        cx: &mut CurrentRealm,
286        channel_id: DataChannelId,
287        event: DataChannelEvent,
288    ) {
289        if self.closed.get() {
290            return;
291        }
292
293        match event {
294            DataChannelEvent::NewChannel => {
295                let channel = RTCDataChannel::new(
296                    &self.global(),
297                    self,
298                    USVString::from("".to_owned()),
299                    &RTCDataChannelInit::empty(),
300                    Some(channel_id),
301                    CanGc::from_cx(cx),
302                );
303
304                let event = RTCDataChannelEvent::new(
305                    self.global().as_window(),
306                    atom!("datachannel"),
307                    false,
308                    false,
309                    &channel,
310                    CanGc::from_cx(cx),
311                );
312                event.upcast::<Event>().fire(cx, self.upcast());
313            },
314            _ => {
315                let channel: DomRoot<RTCDataChannel> =
316                    if let Some(channel) = self.data_channels.borrow().get(&channel_id) {
317                        DomRoot::from_ref(&**channel)
318                    } else {
319                        warn!(
320                            "Got an event for an unregistered data channel {:?}",
321                            channel_id
322                        );
323                        return;
324                    };
325
326                match event {
327                    DataChannelEvent::Open => channel.on_open(cx),
328                    DataChannelEvent::Close => channel.on_close(cx),
329                    DataChannelEvent::Error(error) => channel.on_error(cx, error),
330                    DataChannelEvent::OnMessage(message) => channel.on_message(cx, message),
331                    DataChannelEvent::StateChange(state) => channel.on_state_change(cx, state),
332                    DataChannelEvent::NewChannel => unreachable!(),
333                }
334            },
335        };
336    }
337
338    pub(crate) fn register_data_channel(&self, id: DataChannelId, channel: &RTCDataChannel) {
339        if self
340            .data_channels
341            .borrow_mut()
342            .insert(id, Dom::from_ref(channel))
343            .is_some()
344        {
345            warn!("Data channel already registered {:?}", id);
346        }
347    }
348
349    pub(crate) fn unregister_data_channel(&self, id: &DataChannelId) {
350        self.data_channels.borrow_mut().remove(id);
351    }
352
353    /// <https://www.w3.org/TR/webrtc/#update-ice-gathering-state>
354    fn update_gathering_state(&self, cx: &mut js::context::JSContext, state: GatheringState) {
355        // step 1
356        if self.closed.get() {
357            return;
358        }
359
360        // step 2 (state derivation already done by gstreamer)
361        let state: RTCIceGatheringState = state.convert();
362
363        // step 3
364        if state == self.gathering_state.get() {
365            return;
366        }
367
368        // step 4
369        self.gathering_state.set(state);
370
371        // step 5
372        let event = Event::new(
373            &self.global(),
374            atom!("icegatheringstatechange"),
375            EventBubbles::DoesNotBubble,
376            EventCancelable::NotCancelable,
377            CanGc::from_cx(cx),
378        );
379        event.upcast::<Event>().fire(cx, self.upcast());
380
381        // step 6
382        if state == RTCIceGatheringState::Complete {
383            let event = RTCPeerConnectionIceEvent::new(
384                self.global().as_window(),
385                atom!("icecandidate"),
386                None,
387                None,
388                true,
389                CanGc::from_cx(cx),
390            );
391            event.upcast::<Event>().fire(cx, self.upcast());
392        }
393    }
394
395    /// <https://www.w3.org/TR/webrtc/#update-ice-connection-state>
396    fn update_ice_connection_state(&self, cx: &mut JSContext, state: IceConnectionState) {
397        // step 1
398        if self.closed.get() {
399            return;
400        }
401
402        // step 2 (state derivation already done by gstreamer)
403        let state: RTCIceConnectionState = state.convert();
404
405        // step 3
406        if state == self.ice_connection_state.get() {
407            return;
408        }
409
410        // step 4
411        self.ice_connection_state.set(state);
412
413        // step 5
414        let event = Event::new(
415            &self.global(),
416            atom!("iceconnectionstatechange"),
417            EventBubbles::DoesNotBubble,
418            EventCancelable::NotCancelable,
419            CanGc::from_cx(cx),
420        );
421        event.upcast::<Event>().fire(cx, self.upcast());
422    }
423
424    fn update_signaling_state(&self, cx: &mut js::context::JSContext, state: SignalingState) {
425        if self.closed.get() {
426            return;
427        }
428
429        let state: RTCSignalingState = state.convert();
430
431        if state == self.signaling_state.get() {
432            return;
433        }
434
435        self.signaling_state.set(state);
436
437        let event = Event::new(
438            &self.global(),
439            atom!("signalingstatechange"),
440            EventBubbles::DoesNotBubble,
441            EventCancelable::NotCancelable,
442            CanGc::from_cx(cx),
443        );
444        event.upcast::<Event>().fire(cx, self.upcast());
445    }
446
447    fn create_offer(&self) {
448        let generation = self.offer_answer_generation.get();
449        let task_source = self
450            .global()
451            .task_manager()
452            .networking_task_source()
453            .to_sendable();
454        let this = Trusted::new(self);
455        self.controller
456            .borrow_mut()
457            .as_ref()
458            .unwrap()
459            .create_offer(Box::new(move |desc: SessionDescription| {
460                task_source.queue(task!(offer_created: move || {
461                    let this = this.root();
462                    if this.offer_answer_generation.get() != generation {
463                        // the state has changed since we last created the offer,
464                        // create a fresh one
465                        this.create_offer();
466                    } else {
467                        let init: RTCSessionDescriptionInit = desc.convert();
468                        for promise in this.offer_promises.borrow_mut().drain(..) {
469                            promise.resolve_native(&init, CanGc::deprecated_note());
470                        }
471                    }
472                }));
473            }));
474    }
475
476    fn create_answer(&self) {
477        let generation = self.offer_answer_generation.get();
478        let task_source = self
479            .global()
480            .task_manager()
481            .networking_task_source()
482            .to_sendable();
483        let this = Trusted::new(self);
484        self.controller
485            .borrow_mut()
486            .as_ref()
487            .unwrap()
488            .create_answer(Box::new(move |desc: SessionDescription| {
489                task_source.queue(task!(answer_created: move || {
490                    let this = this.root();
491                    if this.offer_answer_generation.get() != generation {
492                        // the state has changed since we last created the offer,
493                        // create a fresh one
494                        this.create_answer();
495                    } else {
496                        let init: RTCSessionDescriptionInit = desc.convert();
497                        for promise in this.answer_promises.borrow_mut().drain(..) {
498                            promise.resolve_native(&init, CanGc::deprecated_note());
499                        }
500                    }
501                }));
502            }));
503    }
504}
505
506impl RTCPeerConnectionMethods<crate::DomTypeHolder> for RTCPeerConnection {
507    /// <https://w3c.github.io/webrtc-pc/#dom-peerconnection>
508    fn Constructor(
509        window: &Window,
510        proto: Option<HandleObject>,
511        can_gc: CanGc,
512        config: &RTCConfiguration,
513    ) -> Fallible<DomRoot<RTCPeerConnection>> {
514        Ok(RTCPeerConnection::new(window, proto, config, can_gc))
515    }
516
517    // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-icecandidate
518    event_handler!(icecandidate, GetOnicecandidate, SetOnicecandidate);
519
520    // https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-ontrack
521    event_handler!(track, GetOntrack, SetOntrack);
522
523    // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-iceconnectionstatechange
524    event_handler!(
525        iceconnectionstatechange,
526        GetOniceconnectionstatechange,
527        SetOniceconnectionstatechange
528    );
529
530    // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-icegatheringstatechange
531    event_handler!(
532        icegatheringstatechange,
533        GetOnicegatheringstatechange,
534        SetOnicegatheringstatechange
535    );
536
537    // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-onnegotiationneeded
538    event_handler!(
539        negotiationneeded,
540        GetOnnegotiationneeded,
541        SetOnnegotiationneeded
542    );
543
544    // https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-signalingstatechange
545    event_handler!(
546        signalingstatechange,
547        GetOnsignalingstatechange,
548        SetOnsignalingstatechange
549    );
550
551    // https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-ondatachannel
552    event_handler!(datachannel, GetOndatachannel, SetOndatachannel);
553
554    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-addicecandidate>
555    fn AddIceCandidate(
556        &self,
557        candidate: &RTCIceCandidateInit,
558        comp: InRealm,
559        can_gc: CanGc,
560    ) -> Rc<Promise> {
561        let p = Promise::new_in_current_realm(comp, can_gc);
562        if candidate.sdpMid.is_none() && candidate.sdpMLineIndex.is_none() {
563            p.reject_error(
564                Error::Type(c"one of sdpMid and sdpMLineIndex must be set".to_owned()),
565                can_gc,
566            );
567            return p;
568        }
569
570        // XXXManishearth add support for sdpMid
571        if candidate.sdpMLineIndex.is_none() {
572            p.reject_error(
573                Error::Type(c"servo only supports sdpMLineIndex right now".to_owned()),
574                can_gc,
575            );
576            return p;
577        }
578
579        // XXXManishearth this should be enqueued
580        // https://w3c.github.io/webrtc-pc/#enqueue-an-operation
581
582        self.controller
583            .borrow_mut()
584            .as_ref()
585            .unwrap()
586            .add_ice_candidate(IceCandidate {
587                sdp_mline_index: candidate.sdpMLineIndex.unwrap() as u32,
588                candidate: candidate.candidate.to_string(),
589            });
590
591        // XXXManishearth add_ice_candidate should have a callback
592        p.resolve_native(&(), can_gc);
593        p
594    }
595
596    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-createoffer>
597    fn CreateOffer(&self, _options: &RTCOfferOptions, comp: InRealm, can_gc: CanGc) -> Rc<Promise> {
598        let p = Promise::new_in_current_realm(comp, can_gc);
599        if self.closed.get() {
600            p.reject_error(Error::InvalidState(None), can_gc);
601            return p;
602        }
603        self.offer_promises.borrow_mut().push(p.clone());
604        self.create_offer();
605        p
606    }
607
608    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-createoffer>
609    fn CreateAnswer(
610        &self,
611        _options: &RTCAnswerOptions,
612        comp: InRealm,
613        can_gc: CanGc,
614    ) -> Rc<Promise> {
615        let p = Promise::new_in_current_realm(comp, can_gc);
616        if self.closed.get() {
617            p.reject_error(Error::InvalidState(None), can_gc);
618            return p;
619        }
620        self.answer_promises.borrow_mut().push(p.clone());
621        self.create_answer();
622        p
623    }
624
625    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-localdescription>
626    fn GetLocalDescription(&self) -> Option<DomRoot<RTCSessionDescription>> {
627        self.local_description.get()
628    }
629
630    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-remotedescription>
631    fn GetRemoteDescription(&self) -> Option<DomRoot<RTCSessionDescription>> {
632        self.remote_description.get()
633    }
634
635    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-setlocaldescription>
636    fn SetLocalDescription(
637        &self,
638        desc: &RTCSessionDescriptionInit,
639        comp: InRealm,
640        can_gc: CanGc,
641    ) -> Rc<Promise> {
642        // XXXManishearth validate the current state
643        let p = Promise::new_in_current_realm(comp, can_gc);
644        let this = Trusted::new(self);
645        let desc: SessionDescription = desc.convert();
646        let trusted_promise = TrustedPromise::new(p.clone());
647        let task_source = self
648            .global()
649            .task_manager()
650            .networking_task_source()
651            .to_sendable();
652        self.controller
653            .borrow_mut()
654            .as_ref()
655            .unwrap()
656            .set_local_description(
657                desc.clone(),
658                Box::new(move || {
659                    task_source.queue(task!(local_description_set: move || {
660                        // XXXManishearth spec actually asks for an intricate
661                        // dance between pending/current local/remote descriptions
662                        let this = this.root();
663                        let desc = desc.convert();
664                        let desc = RTCSessionDescription::Constructor(
665                            this.global().as_window(),
666                            None,
667                            CanGc::deprecated_note(),
668                            &desc,
669                        ).unwrap();
670                        this.local_description.set(Some(&desc));
671                        trusted_promise.root().resolve_native(&(), CanGc::deprecated_note())
672                    }));
673                }),
674            );
675        p
676    }
677
678    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-setremotedescription>
679    fn SetRemoteDescription(
680        &self,
681        desc: &RTCSessionDescriptionInit,
682        comp: InRealm,
683        can_gc: CanGc,
684    ) -> Rc<Promise> {
685        // XXXManishearth validate the current state
686        let p = Promise::new_in_current_realm(comp, can_gc);
687        let this = Trusted::new(self);
688        let desc: SessionDescription = desc.convert();
689        let trusted_promise = TrustedPromise::new(p.clone());
690        let task_source = self
691            .global()
692            .task_manager()
693            .networking_task_source()
694            .to_sendable();
695        self.controller
696            .borrow_mut()
697            .as_ref()
698            .unwrap()
699            .set_remote_description(
700                desc.clone(),
701                Box::new(move || {
702                    task_source.queue(task!(remote_description_set: move || {
703                        // XXXManishearth spec actually asks for an intricate
704                        // dance between pending/current local/remote descriptions
705                        let this = this.root();
706                        let desc = desc.convert();
707                        let desc = RTCSessionDescription::Constructor(
708                            this.global().as_window(),
709                            None,
710                            CanGc::deprecated_note(),
711                            &desc,
712                        ).unwrap();
713                        this.remote_description.set(Some(&desc));
714                        trusted_promise.root().resolve_native(&(), CanGc::deprecated_note())
715                    }));
716                }),
717            );
718        p
719    }
720
721    /// <https://w3c.github.io/webrtc-pc/#legacy-interface-extensions>
722    fn AddStream(&self, stream: &MediaStream) {
723        for track in &*stream.get_tracks() {
724            self.controller
725                .borrow()
726                .as_ref()
727                .unwrap()
728                .add_stream(&track.id());
729        }
730    }
731
732    /// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-icegatheringstate>
733    fn IceGatheringState(&self) -> RTCIceGatheringState {
734        self.gathering_state.get()
735    }
736
737    /// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-iceconnectionstate>
738    fn IceConnectionState(&self) -> RTCIceConnectionState {
739        self.ice_connection_state.get()
740    }
741
742    /// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-signalingstate>
743    fn SignalingState(&self) -> RTCSignalingState {
744        self.signaling_state.get()
745    }
746
747    /// <https://www.w3.org/TR/webrtc/#dom-rtcpeerconnection-close>
748    fn Close(&self, cx: &mut js::context::JSContext) {
749        // Step 1
750        if self.closed.get() {
751            return;
752        }
753        // Step 2
754        self.closed.set(true);
755
756        // Step 4
757        self.signaling_state.set(RTCSignalingState::Closed);
758
759        // Step 5 handled by backend
760        self.controller.borrow_mut().as_ref().unwrap().quit();
761
762        // Step 6
763        for (_, val) in self.data_channels.borrow().iter() {
764            val.on_state_change(cx, DataChannelState::Closed);
765        }
766
767        // Step 7-10
768        // (no current support for transports, etc)
769
770        // Step 11
771        self.ice_connection_state.set(RTCIceConnectionState::Closed);
772
773        // Step 11
774        // (no current support for connection state)
775    }
776
777    /// <https://www.w3.org/TR/webrtc/#dom-peerconnection-createdatachannel>
778    fn CreateDataChannel(
779        &self,
780        label: USVString,
781        init: &RTCDataChannelInit,
782    ) -> DomRoot<RTCDataChannel> {
783        RTCDataChannel::new(
784            &self.global(),
785            self,
786            label,
787            init,
788            None,
789            CanGc::deprecated_note(),
790        )
791    }
792
793    /// <https://w3c.github.io/webrtc-pc/#dom-rtcpeerconnection-addtransceiver>
794    fn AddTransceiver(
795        &self,
796        _track_or_kind: MediaStreamTrackOrString,
797        init: &RTCRtpTransceiverInit,
798    ) -> DomRoot<RTCRtpTransceiver> {
799        RTCRtpTransceiver::new(&self.global(), init.direction, CanGc::deprecated_note())
800    }
801}
802
803impl Convert<RTCSessionDescriptionInit> for SessionDescription {
804    fn convert(self) -> RTCSessionDescriptionInit {
805        let type_ = match self.type_ {
806            SdpType::Answer => RTCSdpType::Answer,
807            SdpType::Offer => RTCSdpType::Offer,
808            SdpType::Pranswer => RTCSdpType::Pranswer,
809            SdpType::Rollback => RTCSdpType::Rollback,
810        };
811        RTCSessionDescriptionInit {
812            type_,
813            sdp: self.sdp.into(),
814        }
815    }
816}
817
818impl Convert<SessionDescription> for &RTCSessionDescriptionInit {
819    fn convert(self) -> SessionDescription {
820        let type_ = match self.type_ {
821            RTCSdpType::Answer => SdpType::Answer,
822            RTCSdpType::Offer => SdpType::Offer,
823            RTCSdpType::Pranswer => SdpType::Pranswer,
824            RTCSdpType::Rollback => SdpType::Rollback,
825        };
826        SessionDescription {
827            type_,
828            sdp: self.sdp.to_string(),
829        }
830    }
831}
832
833impl Convert<RTCIceGatheringState> for GatheringState {
834    fn convert(self) -> RTCIceGatheringState {
835        match self {
836            GatheringState::New => RTCIceGatheringState::New,
837            GatheringState::Gathering => RTCIceGatheringState::Gathering,
838            GatheringState::Complete => RTCIceGatheringState::Complete,
839        }
840    }
841}
842
843impl Convert<RTCIceConnectionState> for IceConnectionState {
844    fn convert(self) -> RTCIceConnectionState {
845        match self {
846            IceConnectionState::New => RTCIceConnectionState::New,
847            IceConnectionState::Checking => RTCIceConnectionState::Checking,
848            IceConnectionState::Connected => RTCIceConnectionState::Connected,
849            IceConnectionState::Completed => RTCIceConnectionState::Completed,
850            IceConnectionState::Disconnected => RTCIceConnectionState::Disconnected,
851            IceConnectionState::Failed => RTCIceConnectionState::Failed,
852            IceConnectionState::Closed => RTCIceConnectionState::Closed,
853        }
854    }
855}
856
857impl Convert<RTCSignalingState> for SignalingState {
858    fn convert(self) -> RTCSignalingState {
859        match self {
860            SignalingState::Stable => RTCSignalingState::Stable,
861            SignalingState::HaveLocalOffer => RTCSignalingState::Have_local_offer,
862            SignalingState::HaveRemoteOffer => RTCSignalingState::Have_remote_offer,
863            SignalingState::HaveLocalPranswer => RTCSignalingState::Have_local_pranswer,
864            SignalingState::HaveRemotePranswer => RTCSignalingState::Have_remote_pranswer,
865            SignalingState::Closed => RTCSignalingState::Closed,
866        }
867    }
868}
script/dom/webrtc/rtcpeerconnection.rs

script/dom/webrtc/
rtcpeerconnection.rs
