feat(adapter): use with firefox (#628)

* feat(adapter): use with firefox

* squash: add comment about sdptransform workaround

modules/RTC/JitsiTrack.js

 import { getLogger } from 'jitsi-meet-logger';
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
 import * as MediaType from '../../service/RTC/MediaType';
-import RTCBrowserType from './RTCBrowserType';
 import RTCUtils from './RTCUtils';
 
 const logger = getLogger(__filename);
     'track_ended': 'onended'
 };
 
-/**
- * This implements 'onended' callback normally fired by WebRTC after the stream
- * is stopped. There is no such behaviour yet in FF, so we have to add it.
- * @param jitsiTrack our track object holding the original WebRTC stream object
- * to which 'onended' handling will be added.
- */
-function implementOnEndedHandling(jitsiTrack) {
-    const stream = jitsiTrack.getOriginalStream();
-
-    if (!stream) {
-        return;
-    }
-
-    const originalStop = stream.stop;
-
-    stream.stop = function() {
-        originalStop.apply(stream);
-        if (jitsiTrack.isActive()) {
-            stream.onended();
-        }
-    };
-}
-
 /**
  * Adds onended/oninactive handler to a MediaStream.
  * @param mediaStream a MediaStream to attach onended/oninactive handler
 
     /* eslint-enable max-params */
 
-    /**
-     * Binds the inactive handler.
-     * @param {Function} streamInactiveHandler
-     * @private
-     */
-    _bindInactiveHandler(streamInactiveHandler) {
-        if (RTCBrowserType.isFirefox()) {
-            implementOnEndedHandling(this);
-        }
-        addMediaStreamInactiveHandler(this.stream, streamInactiveHandler);
-    }
-
     /**
      * Sets handler to the WebRTC MediaStream or MediaStreamTrack object
      * depending on the passed type.
                 this._setHandler(type, this.handlers.get(type));
             }
             if (this._streamInactiveHandler) {
-                this._bindInactiveHandler(this._streamInactiveHandler);
+                addMediaStreamInactiveHandler(
+                    this.stream, this._streamInactiveHandler);
             }
         }
     }

modules/RTC/RTCBrowserType.js

      * @returns {boolean}
      */
     usesNewGumFlow() {
-        return RTCBrowserType.isChrome()
-            && RTCBrowserType.getChromeVersion() >= 61;
+        return (RTCBrowserType.isChrome()
+            && RTCBrowserType.getChromeVersion() >= 61)
+            || RTCBrowserType.isFirefox();
     },
 
     /**

modules/RTC/RTCUtils.js

           RTCIceCandidate: true,
           RTCPeerConnection,
           RTCSessionDescription: true,
-          mozRTCIceCandidate,
-          mozRTCPeerConnection,
-          mozRTCSessionDescription,
           webkitMediaStream,
           webkitRTCPeerConnection,
           webkitURL
                 };
                 this.getStreamID = stream => stream.id;
                 this.getTrackID = track => track.id;
-            } else if (RTCBrowserType.isFirefox()) {
-                const FFversion = RTCBrowserType.getFirefoxVersion();
-
-                if (FFversion < 40) {
-                    rejectWithWebRTCNotSupported(
-                        `Firefox version too old: ${FFversion}.`
-                            + ' Required >= 40.',
-                        reject);
-
-                    return;
-                }
-                this.RTCPeerConnectionType = mozRTCPeerConnection;
-                this.getUserMedia
-                    = wrapGetUserMedia(
-                        navigator.mozGetUserMedia.bind(navigator));
-                this.enumerateDevices = rawEnumerateDevicesWithCallback;
-                this.pcConstraints = {};
-                this.attachMediaStream
-                    = wrapAttachMediaStream((element, stream) => {
-                        // srcObject is being standardized and FF will
-                        // eventually support that unprefixed. FF also supports
-                        // the "element.src = URL.createObjectURL(...)" combo,
-                        // but that will be deprecated in favour of srcObject.
-                        //
-                        // https://groups.google.com/forum/#!topic/
-                        // mozilla.dev.media/pKOiioXonJg
-                        // https://github.com/webrtc/samples/issues/302
-                        if (element) {
-                            defaultSetVideoSrc(element, stream);
-                            if (stream) {
-                                element.play();
-                            }
-                        }
-
-                        return element;
-                    });
-                this.getStreamID = function(stream) {
-                    let id = stream.id;
-
-                    if (!id) {
-                        let tracks = stream.getVideoTracks();
-
-                        if (!tracks || tracks.length === 0) {
-                            tracks = stream.getAudioTracks();
-                        }
-                        id = tracks[0].id;
-                    }
-
-                    return SDPUtil.filterSpecialChars(id);
-                };
-                this.getTrackID = function(track) {
-                    return track.id;
-                };
-
-                /* eslint-disable no-global-assign, no-native-reassign */
-                RTCSessionDescription = mozRTCSessionDescription;
-                RTCIceCandidate = mozRTCIceCandidate;
-
-                /* eslint-enable no-global-assign, no-native-reassign */
-
             } else if (RTCBrowserType.isOpera()
                     || RTCBrowserType.isNWJS()
                     || RTCBrowserType.isElectron()

modules/xmpp/SDPUtil.js

             }
         }
         if (payloadType) {
+            // Call toString() on payloads to get around an issue within
+            // SDPTransform that sets payloads as a number, instead of a string,
+            // when there is only one payload.
             const payloadTypes
-                = videoMLine.payloads.split(' ').map(p => parseInt(p, 10));
+                = videoMLine.payloads
+                    .toString()
+                    .split(' ')
+                    .map(p => parseInt(p, 10));
             const payloadIndex = payloadTypes.indexOf(payloadType);
 
             payloadTypes.splice(payloadIndex, 1);
 
             removePts.push(...rtxPts.map(item => item.payload));
 
-            const allPts = videoMLine.payloads.split(' ').map(Number);
+            // Call toString() on payloads to get around an issue within
+            // SDPTransform that sets payloads as a number, instead of a string,
+            // when there is only one payload.
+            const allPts = videoMLine.payloads
+                .toString()
+                .split(' ')
+                .map(Number);
             const keepPts = allPts.filter(pt => removePts.indexOf(pt) === -1);
 
             if (keepPts.length === 0) {