core: refactor initialization not to return a Promise (continued)

1. The example was using the Promise return value of JitsiMeetJS.init
which is no longer possible/correct after commit "core: refactor
initialization not to return a Promise".

2. We went back and forth with the value returned by JitsiMeetJS.init:
we initially didn't return a value, then we started returning a Promise,
and now we're not returning a value. Whether we'll go back to returning
a value is up in the air. Anyway, the return value is practically
determined by the last in a chain of function calls: JitsiMeetJS, RTC,
RTCUtil. Since the chain is not really documented, it will not hurt much
to make it easier to refactor the chain by "composing" the functions.

JitsiMeetJS.js

             Statistics.sendLog(JSON.stringify(logObject));
         }
 
-        RTC.init(options);
+        return RTC.init(options);
     },
 
     /**
     },
 
     /**
-     * Returns wether the current environment supported WebRTC (for use with
-     * this library) or not.
+     * Returns whether the current execution environment supports WebRTC (for
+     * use within this library).
      *
-     * @returns {boolean} true if supported, false otherwise.
+     * @returns {boolean} {@code true} if WebRTC is supported in the current
+     * execution environment (for use within this library); {@code false},
+     * otherwise.
      */
     isWebRtcSupported() {
         return RTC.isWebRtcSupported();

doc/example/example.js

     desktopSharingFirefoxDisabled: true
 };
 
-JitsiMeetJS.init(initOptions)
-    .then(() => {
-        connection = new JitsiMeetJS.JitsiConnection(null, null, options);
-
-        connection.addEventListener(
-            JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED,
-            onConnectionSuccess);
-        connection.addEventListener(
-            JitsiMeetJS.events.connection.CONNECTION_FAILED,
-            onConnectionFailed);
-        connection.addEventListener(
-            JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED,
-            disconnect);
-
-        JitsiMeetJS.mediaDevices.addEventListener(
-            JitsiMeetJS.events.mediaDevices.DEVICE_LIST_CHANGED,
-            onDeviceListChanged);
-
-        connection.connect();
-        JitsiMeetJS.createLocalTracks({ devices: [ 'audio', 'video' ] })
-            .then(onLocalTracks)
-            .catch(error => {
-                throw error;
-            });
-    })
-    .catch(error => console.log(error));
+JitsiMeetJS.init(initOptions);
+
+connection = new JitsiMeetJS.JitsiConnection(null, null, options);
+
+connection.addEventListener(
+    JitsiMeetJS.events.connection.CONNECTION_ESTABLISHED,
+    onConnectionSuccess);
+connection.addEventListener(
+    JitsiMeetJS.events.connection.CONNECTION_FAILED,
+    onConnectionFailed);
+connection.addEventListener(
+    JitsiMeetJS.events.connection.CONNECTION_DISCONNECTED,
+    disconnect);
+
+JitsiMeetJS.mediaDevices.addEventListener(
+    JitsiMeetJS.events.mediaDevices.DEVICE_LIST_CHANGED,
+    onDeviceListChanged);
+
+connection.connect();
+
+JitsiMeetJS.createLocalTracks({ devices: [ 'audio', 'video' ] })
+    .then(onLocalTracks)
+    .catch(error => {
+        throw error;
+    });
 
 if (JitsiMeetJS.mediaDevices.isDeviceChangeAvailable('output')) {
     JitsiMeetJS.mediaDevices.enumerateDevices(devices => {

modules/RTC/RTC.js

     static init(options = {}) {
         this.options = options;
 
-        RTCUtils.init(this.options);
+        return RTCUtils.init(this.options);
     }
 
     /**
     }
 
     /**
-     * Returns wether the current environment supported WebRTC (for use with
-     * this library) or not.
+     * Returns whether the current execution environment supports WebRTC (for
+     * use within this library).
      *
-     * @returns {boolean} true if supported, false otherwise.
+     * @returns {boolean} {@code true} if WebRTC is supported in the current
+     * execution environment (for use within this library); {@code false},
+     * otherwise.
      */
     static isWebRtcSupported() {
         return browser.isSupported();

modules/RTC/RTCUtils.js

           webkitRTCPeerConnection,
           webkitURL
 */
+
 import { AVAILABLE_DEVICE } from '../../service/statistics/AnalyticsEvents';
 import CameraFacingMode from '../../service/RTC/CameraFacingMode';
 import EventEmitter from 'events';
             : function(callback) {
                 MediaStreamTrack.getSources(
                     sources =>
-                        callback(
-                            sources.map(convertMediaStreamTrackSource)));
+                        callback(sources.map(convertMediaStreamTrackSource)));
             };
 }
 
 
     /**
      * Depending on the browser, sets difference instance methods for
-     * interacting with user media and adds methods to native webrtc related
+     * interacting with user media and adds methods to native WebRTC-related
      * objects. Also creates an instance variable for peer connection
      * constraints.
      *
 
             this.getUserMedia
                 = (constraints, successCallback, errorCallback) =>
-                    window.navigator.mediaDevices
-                        .getUserMedia(constraints)
+                    window.navigator.mediaDevices.getUserMedia(constraints)
                         .then(stream => {
                             successCallback && successCallback(stream);
 
                     }
                 });
 
-            this.getStreamID = stream => stream.id;
-            this.getTrackID = track => track.id;
+            this.getStreamID = ({ id }) => id;
+            this.getTrackID = ({ id }) => id;
         } else if (browser.isChrome() // this is chrome < 61
                 || browser.isOpera()
                 || browser.isNWJS()
                 || browser.isReactNative()) {
 
             this.RTCPeerConnectionType = webkitRTCPeerConnection;
-            const getUserMedia
-                = navigator.webkitGetUserMedia.bind(navigator);
+
+            const getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
 
             this.getUserMedia = wrapGetUserMedia(getUserMedia);
+
             this.enumerateDevices = rawEnumerateDevicesWithCallback;
 
             this.attachMediaStream
 
                     return element;
                 });
-            this.getStreamID = function(stream) {
-                // A. MediaStreams from FF endpoints have the characters '{'
-                // and '}' that make jQuery choke.
-                // B. The react-native-webrtc implementation that we use on
-                // React Native at the time of this writing returns a number
-                // for the id of MediaStream. Let's just say that a number
-                // contains no special characters.
-                const id = stream.id;
-
-                // XXX The return statement is affected by automatic
-                // semicolon insertion (ASI). No line terminator is allowed
-                // between the return keyword and the expression.
+
+            this.getStreamID = function({ id }) {
+                // A. MediaStreams from FF endpoints have the characters '{' and
+                // '}' that make jQuery choke.
+                // B. The react-native-webrtc implementation that we use at the
+                // time of this writing returns a number for the id of
+                // MediaStream. Let's just say that a number contains no special
+                // characters.
                 return (
                     typeof id === 'number'
                         ? id
                         : SDPUtil.filterSpecialChars(id));
             };
-            this.getTrackID = function(track) {
-                return track.id;
-            };
+            this.getTrackID = ({ id }) => id;
 
             if (!webkitMediaStream.prototype.getVideoTracks) {
                 webkitMediaStream.prototype.getVideoTracks = function() {
             };
 
             // Remote MediaStreamTracks generated by ORTC (within a
-            // RTCRtpReceiver) have an internally/random id which does not
-            // match the track id signaled in the remote SDP. The shim adds
-            // a custom jitsi-id property with the original track id.
-            this.getTrackID = function(track) {
-                return track.jitsiRemoteId || track.id;
-            };
+            // RTCRtpReceiver) have an internally/random id which does not match
+            // the track id signaled in the remote SDP. The shim adds a custom
+            // jitsi-id property with the original track id.
+            this.getTrackID = track => track.jitsiRemoteId || track.id;
         } else {
-            logger.error('Endpoint does not appear to be WebRTC-capable');
+            const message = 'Endpoint does not appear to be WebRTC-capable';
 
-            throw new Error('Unsupporded endpoint');
+            logger.error(message);
+            throw new Error(message);
         }
 
         this._initPCConstraints(options);
 
         screenObtainer.init(
-            options, this.getUserMediaWithConstraints.bind(this));
+            options,
+            this.getUserMediaWithConstraints.bind(this));
 
-        if (this.isDeviceListAvailable()
-                && rawEnumerateDevicesWithCallback) {
+        if (this.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
             rawEnumerateDevicesWithCallback(ds => {
                 availableDevices = ds.splice(0);
 
                 logger.debug('Available devices: ', availableDevices);
                 sendDeviceListToAnalytics(availableDevices);
 
-                eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
+                eventEmitter.emit(
+                    RTCEvents.DEVICE_LIST_AVAILABLE,
                     availableDevices);
 
                 if (isDeviceChangeEventSupported) {
                     navigator.mediaDevices.addEventListener(
                         'devicechange',
-                        () => this.enumerateDevices(
-                                onMediaDevicesListChanged));
+                        () => this.enumerateDevices(onMediaDevicesListChanged));
                 } else {
                     pollForAvailableMediaDevices();
                 }
     }
 
     /**
-     * Checks if its possible to enumerate available cameras/microphones.
+     * Checks whether it is possible to enumerate available cameras/microphones.
      *
-     * @returns {boolean} true if the device listing is available or false
-     * otherwise.
+     * @returns {boolean} {@code true} if the device listing is available;
+     * {@code false}, otherwise.
      */
     isDeviceListAvailable() {
         return Boolean(