feat(screenSharing): Add support for audio screen sharing on electron

modules/RTC/RTCUtils.js

  * @param {Object} options.frameRate - used only for dekstop sharing.
  * @param {Object} options.frameRate.min - Minimum fps
  * @param {Object} options.frameRate.max - Maximum fps
+ * @param {bool}   options.screenShareAudio - Used by electron clients to
+ * enable system audio screen sharing.
  */
 function getConstraints(um, options = {}) {
     const constraints = {
             }),
             optional: []
         };
+
+        // Audio screen sharing for electron only works for screen type devices.
+        // i.e. when the user shares the whole desktop.
+        if (browser.isElectron() && options.screenShareAudio
+            && (options.desktopStream.indexOf('screen') >= 0)) {
+
+            // Provide constraints as described by the electron desktop capturer
+            // documentation here:
+            // https://www.electronjs.org/docs/api/desktop-capturer
+            constraints.audio = { mandatory: {
+                chromeMediaSource: constraints.video.mandatory.chromeMediaSource
+            } };
+
+            delete constraints.video.mandatory.chromeMediaSourceId;
+        }
     }
 
     if (options.bandwidth) {
     * @param {Object} options.frameRate - used only for dekstop sharing.
     * @param {Object} options.frameRate.min - Minimum fps
     * @param {Object} options.frameRate.max - Maximum fps
+    * @param {bool}   options.screenShareAudio - Used by electron clients to
+    * enable system audio screen sharing.
     * @returns {Promise} Returns a media stream on success or a JitsiTrackError
     * on failure.
     **/
 
         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} ${constraints} `);
-                    updateGrantedPermissions(um, undefined);
-                    reject(new JitsiTrackError(error, constraints, um));
-                });
+            .then(stream => {
+                logger.log('onUserMediaSuccess');
+                updateGrantedPermissions(um, stream);
+                resolve(stream);
+            })
+            .catch(error => {
+                logger.warn('Failed to get access to local media. '
+                    + ` ${error} ${constraints} `);
+                updateGrantedPermissions(um, undefined);
+                reject(new JitsiTrackError(error, constraints, um));
+            });
         });
     }
 

modules/RTC/ScreenObtainer.js

                     desktopSharingSources: desktopSharingSources
                         || this.options.desktopSharingChromeSources
                 },
-                (streamId, streamType) =>
+                (streamId, streamType, screenShareAudio = false) =>
                     onGetStreamResponse(
                         {
                             response: {
                                 streamId,
-                                streamType
+                                streamType,
+                                screenShareAudio
                             },
                             gumOptions
                         },
  * @param {object} options.response
  * @param {string} options.response.streamId - the streamId for the desktop
  * stream.
+ * @param {bool}   options.response.screenShareAudio - Used by electron clients to
+ * enable system audio screen sharing.
  * @param {string} options.response.error - error to be reported.
  * @param {object} options.gumOptions - options passed to GUM.
  * @param {Function} onSuccess - callback for success.
         },
         onSuccess,
         onFailure) {
-    const { streamId, streamType, error } = options.response || {};
+    const { streamId, streamType, screenShareAudio, error } = options.response || {};
 
     if (streamId) {
         const gumOptions = {
             desktopStream: streamId,
+            screenShareAudio,
             ...options.gumOptions
         };
 

modules/webaudio/AudioMixer.js

     constructor() {
         this._started = false;
         this._streamsToMix = [];
+        this._streamMSSArray = [];
     }
 
     /**
 
         this._started = true;
 
-        // Create ChannelMergerNode and connect all MediaStreams to it.
-        this._channelMerger = this._audioContext.createChannelMerger(this._streamsToMix.length);
+        this._mixedMSD = this._audioContext.createMediaStreamDestination();
 
         for (const stream of this._streamsToMix) {
             const streamMSS = this._audioContext.createMediaStreamSource(stream);
 
-            streamMSS.connect(this._channelMerger);
-        }
+            streamMSS.connect(this._mixedMSD);
 
-        this._mixedMSD = this._audioContext.createMediaStreamDestination();
-        this._channelMerger.connect(this._mixedMSD);
+            // Maintain a list of MediaStreamAudioSourceNode so we can disconnect them on reset.
+            this._streamMSSArray.push(streamMSS);
+        }
 
         return this._mixedMSD.stream;
     }
 
     /**
-     * Disconnect the ChannelMergerNode stopping the audio mix process.References to MediaStreams are also cleared.
+     * Disconnect MediaStreamAudioSourceNode and clear references.
      *
      * @returns {void}
      */
         this._started = false;
         this._streamsToMix = [];
 
-        if (this._channelMerger) {
-            this._channelMerger.disconnect();
+        // Clean up created MediaStreamAudioSourceNode.
+        for (const streamMSS of this._streamMSSArray) {
+            streamMSS.disconnect();
         }
 
+        this._streamMSSArray = [];
+
         if (this._audioContext) {
             this._audioContext = undefined;
         }