feat(GUM): timeout.

JitsiTrackError.js

     = 'Requested device(s) was/were not found: ';
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.CONSTRAINT_FAILED]
     = 'Constraint could not be satisfied: ';
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TIMEOUT]
+    = 'Could not start media source. Timeout occured!';
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_IS_DISPOSED]
     = 'Track has been already disposed';
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.TRACK_NO_STREAM_FOUND]

JitsiTrackErrors.js

 export const SCREENSHARING_USER_CANCELED
     = 'gum.screensharing_user_canceled';
 
+
+/**
+ * Indicates that the timeout passed to the obtainAudioAndVideoPermissions has expired without GUM resolving.
+ */
+export const TIMEOUT = 'gum.timeout';
+
 /**
  * An error which indicates that track has been already disposed and cannot
  * be longer used.

modules/RTC/RTCUtils.js

 import clonedeep from 'lodash.clonedeep';
 
 import JitsiTrackError from '../../JitsiTrackError';
+import * as JitsiTrackErrors from '../../JitsiTrackErrors';
 import CameraFacingMode from '../../service/RTC/CameraFacingMode';
 import * as MediaType from '../../service/RTC/MediaType';
 import RTCEvents from '../../service/RTC/RTCEvents';
     * @param {Object} options.frameRate.max - Maximum fps
     * @param {bool}   options.screenShareAudio - Used by electron clients to
     * enable system audio screen sharing.
+    * @param {number} options.timeout - The timeout in ms for GUM.
     * @returns {Promise} Returns a media stream on success or a JitsiTrackError
     * on failure.
     **/
     getUserMediaWithConstraints(um, options = {}) {
-        const constraints = getConstraints(um, options);
+        const {
+            timeout,
+            ...otherOptions
+        } = options;
+        const constraints = getConstraints(um, otherOptions);
 
         logger.info('Get media constraints', JSON.stringify(constraints));
 
-        return new Promise((resolve, reject) => {
-            navigator.mediaDevices.getUserMedia(constraints)
-            .then(stream => {
-                logger.log('onUserMediaSuccess');
-                updateGrantedPermissions(um, stream);
-                resolve(stream);
-            })
-            .catch(error => {
-                logger.warn(`Failed to get access to local media. ${error} ${JSON.stringify(constraints)}`);
-                updateGrantedPermissions(um, undefined);
-                reject(new JitsiTrackError(error, constraints, um));
-            });
-        });
+        return this._getUserMedia(um, constraints, timeout);
     }
 
     /**
      *
      * @param {array} umDevices which devices to acquire (e.g. audio, video)
      * @param {Object} constraints - Stream specifications to use.
+     * @param {number} timeout - The timeout in ms for GUM.
      * @returns {Promise}
      */
-    _newGetUserMediaWithConstraints(umDevices, constraints = {}) {
+    _getUserMedia(umDevices, constraints = {}, timeout = 0) {
         return new Promise((resolve, reject) => {
+            let gumTimeout, timeoutExpired = false;
+
+            if (typeof timeout === 'number' && !isNaN(timeout) && timeout > 0) {
+                gumTimeout = setTimeout(() => {
+                    timeoutExpired = true;
+                    gumTimeout = undefined;
+                    reject(new JitsiTrackError(JitsiTrackErrors.TIMEOUT));
+                }, timeout);
+            }
+
             navigator.mediaDevices.getUserMedia(constraints)
                 .then(stream => {
                     logger.log('onUserMediaSuccess');
                     updateGrantedPermissions(umDevices, stream);
-                    resolve(stream);
+                    if (!timeoutExpired) {
+                        if (typeof gumTimeout !== 'undefined') {
+                            clearTimeout(gumTimeout);
+                        }
+                        resolve(stream);
+                    }
                 })
                 .catch(error => {
                     logger.warn(`Failed to get access to local media. ${error} ${JSON.stringify(constraints)}`);
                     updateGrantedPermissions(umDevices, undefined);
-                    reject(new JitsiTrackError(error, constraints, umDevices));
+                    if (!timeoutExpired) {
+                        if (typeof gumTimeout !== 'undefined') {
+                            clearTimeout(gumTimeout);
+                        }
+                        reject(new JitsiTrackError(error, constraints, umDevices));
+                    }
                 });
         });
     }
     /**
      * Acquire a display stream via the screenObtainer. This requires extra
      * logic compared to use screenObtainer versus normal device capture logic
-     * in RTCUtils#_newGetUserMediaWithConstraints.
+     * in RTCUtils#_getUserMedia.
      *
      * @param {Object} options
      * @param {string[]} options.desktopSharingSources
     newObtainAudioAndVideoPermissions(options) {
         logger.info('Using the new gUM flow');
 
+        const {
+            timeout,
+            ...otherOptions
+        } = options;
+
         const mediaStreamsMetaData = [];
 
         // Declare private functions to be used in the promise chain below.
          * @returns {Promise}
          */
         const maybeRequestDesktopDevice = function() {
-            const umDevices = options.devices || [];
+            const umDevices = otherOptions.devices || [];
             const isDesktopDeviceRequested
                 = umDevices.indexOf('desktop') !== -1;
 
                 desktopSharingSourceDevice,
                 desktopSharingSources,
                 desktopSharingFrameRate
-            } = options;
+            } = otherOptions;
 
             // Attempt to use a video input device as a screenshare source if
             // the option is defined.
                 // Leverage the helper used by {@link _newGetDesktopMedia} to
                 // get constraints for the desktop stream.
                 const { gumOptions, trackOptions }
-                    = this._parseDesktopSharingOptions(options);
+                    = this._parseDesktopSharingOptions(otherOptions);
 
                 const constraints = {
                     video: {
                     }
                 };
 
-                return this._newGetUserMediaWithConstraints(
-                    requestedDevices, constraints)
+                return this._getUserMedia(requestedDevices, constraints, timeout)
                     .then(stream => {
                         const track = stream && stream.getTracks()[0];
                         const applyConstrainsPromise
          * @returns {Promise}
          */
         const maybeRequestCaptureDevices = function() {
-            const umDevices = options.devices || [ 'audio', 'video' ];
+            const umDevices = otherOptions.devices || [ 'audio', 'video' ];
             const requestedCaptureDevices = umDevices.filter(device => device === 'audio' || device === 'video');
 
             if (!requestedCaptureDevices.length) {
             }
 
             const constraints = newGetConstraints(
-                requestedCaptureDevices, options);
+                requestedCaptureDevices, otherOptions);
 
             logger.info('Got media constraints: ', JSON.stringify(constraints));
 
-            return this._newGetUserMediaWithConstraints(
-                requestedCaptureDevices, constraints);
+            return this._getUserMedia(requestedCaptureDevices, constraints, timeout);
         }.bind(this);
 
         /**
                 mediaStreamsMetaData.push({
                     stream: audioStream,
                     track: audioStream.getAudioTracks()[0],
-                    effects: options.effects
+                    effects: otherOptions.effects
                 });
             }
 
                     stream: videoStream,
                     track: videoStream.getVideoTracks()[0],
                     videoType: VideoType.CAMERA,
-                    effects: options.effects
+                    effects: otherOptions.effects
                 });
             }
         };