feat(sanity): axe IE and Temasys plugin support 🔥🔥🔥

.eslintignore

 # modify as little as possible.
 doc/example/libs/*
 flow-typed/*
-modules/RTC/adapter.screenshare.js
 
 # ESLint will by default ignore its own configuration file. However, there does
 # not seem to be a reason why we will want to risk being inconsistent with our

JitsiMediaDevicesEvents.js

  * access camera and/or microphone. The event provides the following
  * parameters to its listeners:
  *
- * @param {'chrome'|'opera'|'firefox'|'iexplorer'|'safari'|'nwjs'
+ * @param {'chrome'|'opera'|'firefox'|'safari'|'nwjs'
  *  |'react-native'|'android'} environmentType - type of browser or
  *  other execution environment.
  */

JitsiMeetJS.js

     from './modules/connectivity/ParticipantConnectionStatus';
 import RTC from './modules/RTC/RTC';
 import browser from './modules/browser';
-import RTCUIHelper from './modules/RTC/RTCUIHelper';
 import ScriptUtil from './modules/util/ScriptUtil';
 import recordingConstants from './modules/recording/recordingConstants';
 import Statistics from './modules/statistics/statistics';
      */
     util: {
         AuthUtil,
-        RTCUIHelper,
         ScriptUtil,
         browser
     }

doc/API.md

 
     4. mediaDevices
         - DEVICE_LIST_CHANGED - indicates that list of currently connected devices has changed (parameters - devices(MediaDeviceInfo[])).
-        - PERMISSION_PROMPT_IS_SHOWN - Indicates that the environment is currently showing permission prompt to access camera and/or microphone (parameters - environmentType ('chrome'|'opera'|'firefox'|'iexplorer'|'safari'|'nwjs'|'react-native'|'android').
+        - PERMISSION_PROMPT_IS_SHOWN - Indicates that the environment is currently showing permission prompt to access camera and/or microphone (parameters - environmentType ('chrome'|'opera'|'firefox'|'safari'|'nwjs'|'react-native'|'android').
 
 
 * ```JitsiMeetJS.errors``` - JS object that contains all errors used by the API. You can use that object to check the reported errors from the API

modules/RTC/JitsiLocalTrack.js

      */
     _setRealDeviceIdFromDeviceList(devices) {
         const track = this.getTrack();
-
-        // FIXME for temasys video track, label refers to id not the actual
-        // device
         const device = devices.find(
             d => d.kind === `${track.kind}input` && d.label === track.label);
 

modules/RTC/JitsiRemoteTrack.js

 import { createTtfmEvent } from '../../service/statistics/AnalyticsEvents';
 import JitsiTrack from './JitsiTrack';
 import * as JitsiTrackEvents from '../../JitsiTrackEvents';
-import browser from '../browser';
 import Statistics from '../statistics/statistics';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
      * @returns {void}
      */
     _bindMuteHandlers() {
-        // Use feature detection for finding what event handling function is
-        // supported. On Internet Explorer, which uses uses temasys/firebreath,
-        // the track will have attachEvent instead of addEventListener.
-        //
-        // FIXME it would be better to use recently added '_setHandler' method,
-        // but:
-        // 1. It does not allow to set more than one handler to the event
-        // 2. It does mix MediaStream('inactive') with MediaStreamTrack events
-        // 3. Allowing to bind more than one event handler requires too much
-        //    refactoring around camera issues detection.
-        if (this.track.addEventListener) {
-            this.track.addEventListener('mute', () => this._onTrackMute());
-            this.track.addEventListener('unmute', () => this._onTrackUnmute());
-        } else if (this.track.attachEvent) {
-            // FIXME Internet Explorer is not emitting out mute/unmute events.
-            this.track.attachEvent('onmute', () => this._onTrackMute());
-            this.track.attachEvent('onunmute', () => this._onTrackUnmute());
-        }
+        this.track.addEventListener('mute', () => this._onTrackMute());
+        this.track.addEventListener('unmute', () => this._onTrackUnmute());
     }
 
     /**
      * Attach time to first media tracker only if there is conference and only
      * for the first element.
      * @param container the HTML container which can be 'video' or 'audio'
-     * element. It can also be 'object' element if Temasys plugin is in use and
-     * this method has been called previously on video or audio HTML element.
+     * element.
      * @private
      */
     _attachTTFMTracker(container) {
             ttfmTrackerVideoAttached = true;
         }
 
-        if (browser.isTemasysPluginUsed()) {
-            // XXX Don't require Temasys unless it's to be used because it
-            // doesn't run on React Native, for example.
-            const AdapterJS = require('./adapter.screenshare');
-
-            // FIXME: this is not working for IE11
-            AdapterJS.addEvent(
-                container,
-                'play',
-                this._playCallback.bind(this));
-        } else {
-            container.addEventListener(
-                'canplay',
-                this._playCallback.bind(this));
-        }
+        container.addEventListener('canplay', this._playCallback.bind(this));
     }
 
     /**

modules/RTC/JitsiTrack.js

  * @param handler the handler
  */
 function addMediaStreamInactiveHandler(mediaStream, handler) {
-    // Temasys will use onended
-    if (typeof mediaStream.active === 'undefined') {
-        mediaStream.onended = handler;
-    } else {
-        mediaStream.oninactive = handler;
-    }
+    mediaStream.oninactive = handler;
 }
 
 /**
     /**
      * Attaches the MediaStream of this track to an HTML container.
      * Adds the container to the list of containers that are displaying the
-     * track. Note that Temasys plugin will replace original audio/video element
-     * with 'object' when stream is being attached to the container for the
-     * first time.
-     * * NOTE * if given container element is not visible when the stream is
-     * being attached it will be shown back given that Temasys plugin is
-     * currently in use.
+     * track.
      *
      * @param container the HTML container which can be 'video' or 'audio'
-     * element. It can also be 'object' element if Temasys plugin is in use and
-     * this method has been called previously on video or audio HTML element.
+     * element.
      *
-     * @returns potentially new instance of container if it was replaced by the
-     *          library. That's the case when Temasys plugin is in use.
+     * @returns {void}
      */
     attach(container) {
-        let c = container;
-
         if (this.stream) {
-            c = RTCUtils.attachMediaStream(container, this.stream);
+            RTCUtils.attachMediaStream(container, this.stream);
         }
-        this.containers.push(c);
-        this._maybeFireTrackAttached(c);
-        this._attachTTFMTracker(c);
-
-        return c;
+        this.containers.push(container);
+        this._maybeFireTrackAttached(container);
+        this._attachTTFMTracker(container);
     }
 
     /**
      * for the first element.
      *
      * @param {HTMLElement} container the HTML container which can be 'video' or
-     * 'audio' element. It can also be 'object' element if Temasys plugin is in
-     * use and this method has been called previously on video or audio HTML
-     * element.
+     * 'audio' element.
      * @private
      */
     _attachTTFMTracker(container) { // eslint-disable-line no-unused-vars

modules/RTC/RTCUIHelper.js

-/* global $ */
-
-import browser from '../browser';
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
-const RTCUIHelper = {
-
-    /**
-     * Returns the name of 'video' element depending on the browser that we're
-     * currently using.
-     * @returns {string} 'video' or 'object' string name of WebRTC video element
-     */
-    getVideoElementName() {
-        return browser.isTemasysPluginUsed() ? 'object' : 'video';
-    },
-
-    /**
-     * Finds video element inside of the given container.
-     * @param containerElement HTML element node instance which is supposed to
-     *        contain the video element.
-     * @returns {HTMLElement} video HTML element instance if found inside of the
-     *          container or undefined otherwise.
-     */
-    findVideoElement(containerElement) {
-        const videoElemName = RTCUIHelper.getVideoElementName();
-
-        if (!browser.isTemasysPluginUsed()) {
-            return $(containerElement).find(videoElemName)[0];
-        }
-        const matching
-            = $(containerElement).find(
-                ` ${videoElemName}>param[value="video"]`);
-
-        if (matching.length) {
-            if (matching.length > 1) {
-                logger.warn(
-                    'Container with more than one video elements: ',
-                    containerElement);
-            }
-
-            return matching.parent()[0];
-        }
-
-        return undefined;
-    },
-
-    /**
-     * Returns whether or not the video element fires resize events.
-     *
-     * @returns {boolean}
-     */
-    isResizeEventSupported() {
-        return !browser.isTemasysPluginUsed();
-    },
-
-    /**
-     * Sets 'volume' property of given HTML element displaying RTC audio or
-     * video stream.
-     * @param streamElement HTML element to which the RTC stream is attached to.
-     * @param volume the volume value to be set.
-     */
-    setVolume(streamElement, volume) {
-        if (!browser.isIExplorer()) {
-            streamElement.volume = volume;
-        }
-    },
-
-    /**
-     * Sets 'autoplay' property of given HTML element displaying RTC audio or
-     * video stream.
-     * @param streamElement HTML element to which the RTC stream is attached to.
-     * @param autoPlay 'true' or 'false'
-     */
-    setAutoPlay(streamElement, autoPlay) {
-        if (!browser.isIExplorer()) {
-            streamElement.autoplay = autoPlay;
-        }
-    }
-};
-
-export default RTCUIHelper;

modules/RTC/RTCUtils.js

-/* global $,
+/* global
           __filename,
-          attachMediaStream,
           MediaStreamTrack,
           RTCIceCandidate: true,
           RTCPeerConnection,
 
 const logger = getLogger(__filename);
 
-// XXX Don't require Temasys unless it's to be used because it doesn't run on
-// React Native, for example.
-const AdapterJS
-    = browser.isTemasysPluginUsed()
-        ? require('./adapter.screenshare')
-        : undefined;
-
 // Require adapter only for certain browsers. This is being done for
 // react-native, which has its own shims, and while browsers are being migrated
 // over to use adapter's shims.
 const isAudioOutputDeviceChangeAvailable
     = typeof featureDetectionAudioEl.setSinkId !== 'undefined';
 
-let currentlyAvailableMediaDevices;
+let availableDevices;
 
 /**
  * "rawEnumerateDevicesWithCallback" will be initialized only after WebRTC is
 let rawEnumerateDevicesWithCallback;
 
 /**
- *
+ * Initialize {@link rawEnumerateDevicesWithCallback}.
  */
 function initRawEnumerateDevicesWithCallback() {
     rawEnumerateDevicesWithCallback
                     () => callback([]));
             }
 
-            // Safari:
-            // "ReferenceError: Can't find variable: MediaStreamTrack" when
-            // Temasys plugin is not installed yet, have to delay this call
-            // until WebRTC is ready.
-            : typeof MediaStreamTrack !== 'undefined'
-                && MediaStreamTrack.getSources
-                ? function(callback) {
-                    MediaStreamTrack.getSources(
-                        sources =>
-                            callback(
-                                sources.map(convertMediaStreamTrackSource)));
-                }
-                : undefined;
+            // react-native-webrtc
+            : function(callback) {
+                MediaStreamTrack.getSources(
+                    sources =>
+                        callback(
+                            sources.map(convertMediaStreamTrackSource)));
+            };
 }
 
 // TODO: currently no browser supports 'devicechange' event even in nightly
     // @see https://github.com/jitsi/lib-jitsi-meet/pull/136
     const isNewStyleConstraintsSupported
         = browser.isFirefox()
-        || browser.isEdge()
-        || browser.isReactNative()
-        || browser.isTemasysPluginUsed();
+            || browser.isEdge()
+            || browser.isReactNative();
 
     if (um.indexOf('video') >= 0) {
         // same behaviour as true
                 optional: []
             };
 
-        } else if (browser.isTemasysPluginUsed()) {
-            constraints.video = {
-                optional: [
-                    {
-                        sourceId: AdapterJS.WebRTCPlugin.plugin.screensharingKey
-                    }
-                ]
-            };
         } else if (browser.isFirefox()) {
             constraints.video = {
                 mozMediaSource: 'window',
         } else {
             const errmsg
                 = '\'screen\' WebRTC media source is supported only in Chrome'
-                    + ' and with Temasys plugin';
+                    + ' and Firefox';
 
             GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
             logger.error(errmsg);
  * @returns {boolean} - true if list is different, false otherwise.
  */
 function compareAvailableMediaDevices(newDevices) {
-    if (newDevices.length !== currentlyAvailableMediaDevices.length) {
+    if (newDevices.length !== availableDevices.length) {
         return true;
     }
 
 
     return (
         newDevices.map(mediaDeviceInfoToJSON).sort().join('')
-            !== currentlyAvailableMediaDevices
+            !== availableDevices
                 .map(mediaDeviceInfoToJSON).sort().join(''));
 
     /* eslint-enable newline-per-chained-call */
         rawEnumerateDevicesWithCallback(ds => {
             // We don't fire RTCEvents.DEVICE_LIST_CHANGED for the first time
             // we call enumerateDevices(). This is the initial step.
-            if (typeof currentlyAvailableMediaDevices === 'undefined') {
-                currentlyAvailableMediaDevices = ds.slice(0);
+            if (typeof availableDevices === 'undefined') {
+                availableDevices = ds.slice(0);
             } else if (compareAvailableMediaDevices(ds)) {
                 onMediaDevicesListChanged(ds);
             }
  * @emits RTCEvents.DEVICE_LIST_CHANGED
  */
 function onMediaDevicesListChanged(devicesReceived) {
-    currentlyAvailableMediaDevices = devicesReceived.slice(0);
+    availableDevices = devicesReceived.slice(0);
     logger.info(
         'list of media devices has changed:',
-        currentlyAvailableMediaDevices);
+        availableDevices);
 
-    sendDeviceListToAnalytics(currentlyAvailableMediaDevices);
+    sendDeviceListToAnalytics(availableDevices);
 
     const videoInputDevices
-        = currentlyAvailableMediaDevices.filter(d => d.kind === 'videoinput');
+        = availableDevices.filter(d => d.kind === 'videoinput');
     const audioInputDevices
-        = currentlyAvailableMediaDevices.filter(d => d.kind === 'audioinput');
+        = availableDevices.filter(d => d.kind === 'audioinput');
     const videoInputDevicesWithEmptyLabels
         = videoInputDevices.filter(d => d.label === '');
     const audioInputDevicesWithEmptyLabels
     return gUM;
 }
 
-/**
- * Use old MediaStreamTrack to get devices list and
- * convert it to enumerateDevices format.
- * @param {Function} callback function to call when received devices list.
- */
-function enumerateDevicesThroughMediaStreamTrack(callback) {
-    MediaStreamTrack.getSources(
-        sources => callback(sources.map(convertMediaStreamTrackSource)));
-}
-
 /**
  * Converts MediaStreamTrack Source to enumerateDevices format.
  * @param {Object} source
                         if (element) {
                             element.srcObject = stream;
                         }
-
-                        return element;
                     });
 
                 this.getStreamID = stream => stream.id;
                 this.attachMediaStream
                     = wrapAttachMediaStream((element, stream) => {
                         defaultSetVideoSrc(element, stream);
-
-                        return element;
                     });
 
                 // ORTC does not generate remote MediaStreams so those are
                 this.getTrackID = function(track) {
                     return track.jitsiRemoteId || track.id;
                 };
-            } else if (browser.isTemasysPluginUsed()) {
-                // Detect IE/Safari
-                const webRTCReadyCb = () => {
-                    this.RTCPeerConnectionType = RTCPeerConnection;
-                    this.getUserMedia = window.getUserMedia;
-                    this.enumerateDevices
-                        = enumerateDevicesThroughMediaStreamTrack;
-                    this.attachMediaStream
-                        = wrapAttachMediaStream((element, stream) => {
-                            if (stream) {
-                                if (stream.id === 'dummyAudio'
-                                        || stream.id === 'dummyVideo') {
-                                    return;
-                                }
-
-                                // The container must be visible in order to
-                                // play or attach the stream when Temasys plugin
-                                // is in use
-                                const containerSel = $(element);
-
-                                if (browser.isTemasysPluginUsed()
-                                        && !containerSel.is(':visible')) {
-                                    containerSel.show();
-                                }
-                                const video
-                                    = stream.getVideoTracks().length > 0;
-
-                                if (video && !$(element).is(':visible')) {
-                                    throw new Error(
-                                        'video element must be visible to'
-                                            + ' attach video stream');
-                                }
-                            }
-
-                            return attachMediaStream(element, stream);
-                        });
-                    this.getStreamID
-                        = stream => SDPUtil.filterSpecialChars(stream.label);
-                    this.getTrackID
-                        = track => track.id;
-
-                    onReady(
-                        options,
-                        this.getUserMediaWithConstraints.bind(this));
-                };
-                const webRTCReadyPromise
-                    = new Promise(r => AdapterJS.webRTCReady(r));
-
-                // Resolve or reject depending on whether the Temasys plugin is
-                // installed.
-                AdapterJS.WebRTCPlugin.isPluginInstalled(
-                    AdapterJS.WebRTCPlugin.pluginInfo.prefix,
-                    AdapterJS.WebRTCPlugin.pluginInfo.plugName,
-                    AdapterJS.WebRTCPlugin.pluginInfo.type,
-                    /* installed */ () => {
-                        webRTCReadyPromise.then(() => {
-                            webRTCReadyCb();
-                            resolve();
-                        });
-                    },
-                    /* not installed */ () => {
-                        const error
-                            = new Error('Temasys plugin is not installed');
-
-                        error.name = 'WEBRTC_NOT_READY';
-                        error.webRTCReadyPromise = webRTCReadyPromise;
-
-                        reject(error);
-                    });
             } else {
                 rejectWithWebRTCNotSupported(
                     'Browser does not appear to be WebRTC-capable',
 
             this._initPCConstraints(options);
 
-            // Call onReady() if Temasys plugin is not used
-            if (!browser.isTemasysPluginUsed()) {
-                onReady(options, this.getUserMediaWithConstraints.bind(this));
-                resolve();
+            rtcReady = true;
+            eventEmitter.emit(RTCEvents.RTC_READY, true);
+            screenObtainer.init(
+                options, this.getUserMediaWithConstraints.bind(this));
+
+            if (this.isDeviceListAvailable()
+                    && rawEnumerateDevicesWithCallback) {
+                rawEnumerateDevicesWithCallback(ds => {
+                    availableDevices = ds.splice(0);
+
+                    logger.debug('Available devices: ', availableDevices);
+                    sendDeviceListToAnalytics(availableDevices);
+
+                    eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
+                        availableDevices);
+
+                    if (isDeviceChangeEventSupported) {
+                        navigator.mediaDevices.addEventListener(
+                            'devicechange',
+                            () => this.enumerateDevices(
+                                    onMediaDevicesListChanged));
+                    } else {
+                        pollForAvailableMediaDevices();
+                    }
+                });
             }
+
+            resolve();
         });
     }
 
             : browser.isChrome()
                 || browser.isFirefox()
                 || browser.isOpera()
-                || browser.isTemasysPluginUsed()
                 || browser.isNWJS()
                 || browser.isElectron()
                 || browser.isEdge();
      */
     stopMediaStream(mediaStream) {
         mediaStream.getTracks().forEach(track => {
-            // stop() not supported with IE
-            if (!browser.isTemasysPluginUsed() && track.stop) {
+            if (track.stop) {
                 track.stop();
             }
         });
      * @returns {Array} list of available media devices.
      */
     getCurrentlyAvailableMediaDevices() {
-        return currentlyAvailableMediaDevices;
+        return availableDevices;
     }
 
     /**
 function rejectWithWebRTCNotSupported(errorMessage, reject) {
     const error = new Error(errorMessage);
 
-    // WebRTC is not supported either natively or via a known plugin such as
-    // Temasys.
+    // WebRTC is not supported.
+    //
     // XXX The Error class already has a property name which is commonly used to
     // detail the represented error in a non-human-readable way (in contrast to
     // the human-readable property message). I explicitly did not want to
         });
 }
 
-/**
- * In case of IE we continue from 'onReady' callback passed to RTCUtils
- * constructor. It will be invoked by Temasys plugin once it is initialized.
- *
- * @param options
- * @param GUM
- */
-function onReady(options, GUM) {
-    rtcReady = true;
-    eventEmitter.emit(RTCEvents.RTC_READY, true);
-    screenObtainer.init(options, GUM);
-
-    if (rtcUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
-        rawEnumerateDevicesWithCallback(ds => {
-            currentlyAvailableMediaDevices = ds.splice(0);
-
-            logger.info('Available devices: ', currentlyAvailableMediaDevices);
-            sendDeviceListToAnalytics(currentlyAvailableMediaDevices);
-
-            eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
-                currentlyAvailableMediaDevices);
-
-            if (isDeviceChangeEventSupported) {
-                navigator.mediaDevices.addEventListener(
-                    'devicechange',
-                    () => rtcUtils.enumerateDevices(onMediaDevicesListChanged));
-            } else {
-                pollForAvailableMediaDevices();
-            }
-        });
-    }
-}
-
 /**
  * Wraps original attachMediaStream function to set current audio output device
  * if this is supported.

modules/RTC/ScreenObtainer.js

             };
         } else if (browser.isElectron()) {
             return this.obtainScreenOnElectron;
-        } else if (browser.isTemasysPluginUsed()) {
-            // XXX Don't require Temasys unless it's to be used because it
-            // doesn't run on React Native, for example.
-            const plugin
-                = require('./adapter.screenshare').WebRTCPlugin.plugin;
-
-            if (!plugin.HasScreensharingFeature) {
-                logger.warn(
-                    'Screensharing not supported by this plugin version');
-
-                return null;
-            } else if (!plugin.isScreensharingAvailable) {
-                logger.warn(
-                    'Screensharing not available with Temasys plugin on'
-                        + ' this site');
-
-                return null;
-            }
-
-            logger.info('Using Temasys plugin for desktop sharing');
-
-            return obtainWebRTCScreen;
         } else if (browser.isChrome() || browser.isOpera()) {
             if (browser.isVersionLessThan('34')) {
                 logger.info('Chrome extension not supported until ver 34');

modules/RTC/TraceablePeerConnection.js

 
     /**
      * Keeps tracks of the WebRTC <tt>MediaStream</tt>s that have been added to
-     * the underlying WebRTC PeerConnection. An Array is used to avoid errors in
-     * IE11 with adding temasys MediaStream objects into other data structures.
+     * the underlying WebRTC PeerConnection.
      * @type {Array}
      * @private
      */
     this.trace = (what, info) => {
         logger.debug(what, info);
 
-        /*
-        if (info && browser.isIExplorer()) {
-            if (info.length > 1024) {
-                logger.warn('WTRACE', what, info.substr(1024));
-            }
-            if (info.length > 2048) {
-                logger.warn('WTRACE', what, info.substr(2048));
-            }
-        }*/
         this.updateLog.push({
             time: new Date(),
             type: what,
     };
     this.onicecandidate = null;
     this.peerconnection.onicecandidate = event => {
-        // FIXME: this causes stack overflow with Temasys Plugin
-        if (!browser.isTemasysPluginUsed()) {
-            this.trace(
-                'onicecandidate',
-                JSON.stringify(event.candidate, null, ' '));
-        }
+        this.trace(
+            'onicecandidate',
+            JSON.stringify(event.candidate, null, ' '));
 
         if (this.onicecandidate !== null) {
             this.onicecandidate(event);
 
     let ssrcLines = SDPUtil.findLines(mediaLines[0], 'a=ssrc:');
 
-    ssrcLines = ssrcLines.filter(
-        line => {
-            const msid
-                = browser.isTemasysPluginUsed() ? 'mslabel' : 'msid';
-
-
-            return line.indexOf(`${msid}:${streamId}`) !== -1;
-        });
+    ssrcLines
+        = ssrcLines.filter(line => line.indexOf(`msid:${streamId}`) !== -1);
     if (!ssrcLines.length) {
         GlobalOnErrorHandler.callErrorHandler(
             new Error(
         failureCallback(err);
     };
 
-    // NOTE Temasys plugin does not support "bind" on peerconnection methods
     if (isOffer) {
         this.peerconnection.createOffer(
             _successCallback, _errorCallback, constraints);
         candidate,
         successCallback,
         failureCallback) {
-    // var self = this;
-
-    // Calling JSON.stringify with temasys objects causes a stack overflow, so
-    // instead pick out values to log.
     this.trace('addIceCandidate', JSON.stringify({
         candidate: candidate.candidate,
         sdpMid: candidate.sdpMid,
     }, null, ' '));
     this.peerconnection.addIceCandidate(
         candidate, successCallback, failureCallback);
-
-    /* maybe later
-     this.peerconnection.addIceCandidate(candidate,
-     function () {
-     self.trace('addIceCandidateOnSuccess');
-     successCallback();
-     },
-     function (err) {
-     self.trace('addIceCandidateOnFailure', err);
-     failureCallback(err);
-     }
-     );
-     */
 };
 
 /**
  * @returns {void}
  */
 TraceablePeerConnection.prototype.getStats = function(callback, errback) {
-    // TODO: Is this the correct way to handle Opera, Temasys?
     // TODO (brian): After moving all browsers to adapter, check if adapter is
     // accounting for different getStats apis, making the browser-checking-if
     // unnecessary.
-    if (browser.isTemasysPluginUsed()
-        || browser.isReactNative()) {
+    if (browser.isReactNative()) {
         this.peerconnection.getStats(
             null,
             callback,

modules/browser/BrowserCapabilities.js

             && !this.isVersionLessThan('11');
     }
 
-    /**
-     * Checks if Temasys RTC plugin is used.
-     * @returns {boolean}
-     */
-    isTemasysPluginUsed() {
-        // Temasys do not support Microsoft Edge:
-        // http://support.temasys.com.sg/support/solutions/articles/
-        // 5000654345-can-the-temasys-webrtc-plugin-be-used-with-microsoft-edge-
-        return (
-            (this.isSafari()
-                && !this.isSafariWithWebrtc())
-            || (this.isIExplorer()
-                && this.isVersionLessThan('12'))
-        );
-    }
-
     /**
      * Checks if the current browser triggers 'onmute'/'onunmute' events when
      * user's connection is interrupted and the video stops playback.
      * @return {boolean}
      */
     supportsMediaStreamConstructor() {
-        return !this.isReactNative()
-            && !this.isTemasysPluginUsed();
+        return !this.isReactNative();
     }
 
     /**

modules/statistics/LocalStatsCollector.js

  * Provides statistics for the local stream.
  */
 
-import browser from '../browser';
-
 /**
  * Size of the webaudio analyzer buffer.
  * @type {number}
  * @returns {boolean}
  */
 LocalStatsCollector.isLocalStatsSupported = function() {
-    return Boolean(context && !browser.isTemasysPluginUsed());
+    return Boolean(context);
 };

modules/statistics/RTPStatsCollector.js

 const browserSupported = browser.isChrome()
         || browser.isOpera() || browser.isFirefox()
         || browser.isNWJS() || browser.isElectron()
-        || browser.isTemasysPluginUsed() || browser.isEdge()
+        || browser.isEdge()
         || browser.isSafariWithWebrtc() || browser.isReactNative();
 
 /**
     = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
 KEYS_BY_BROWSER_TYPE[browsers.ELECTRON]
     = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
-KEYS_BY_BROWSER_TYPE[browsers.IEXPLORER]
-    = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
 KEYS_BY_BROWSER_TYPE[browsers.SAFARI]
     = KEYS_BY_BROWSER_TYPE[browsers.CHROME];
 KEYS_BY_BROWSER_TYPE[browsers.REACT_NATIVE]

webpack.config.js

             // Transpile ES2015 (aka ES6) to ES5.
 
             exclude: [
-                `${__dirname}/modules/RTC/adapter.screenshare.js`,
                 new RegExp(`${__dirname}/node_modules/(?!js-utils)`)
             ],
             loader: 'babel-loader',