feat(electron): basic Electron SS support

modules/RTC/RTCBrowserType.js

 
     RTC_BROWSER_NWJS: "rtc_browser.nwjs",
 
+    RTC_BROWSER_ELECTRON: "rtc_browser.electron",
+
     RTC_BROWSER_REACT_NATIVE: "rtc_browser.react-native",
 
     /**
         return currentBrowser === RTCBrowserType.RTC_BROWSER_NWJS;
     },
 
+    /**
+     * Checks if current environment is Electron.
+     * @returns {boolean}
+     */
+    isElectron: function () {
+        return currentBrowser === RTCBrowserType.RTC_BROWSER_ELECTRON;
+    },
+
     /**
      * Checks if current environment is React Native.
      * @returns {boolean}
     return version;
 }
 
+/**
+ * Detects Electron environment.
+ */
+function detectElectron (){
+    var userAgent = navigator.userAgent;
+    if (userAgent.match(/Electron/)) {
+        currentBrowser = RTCBrowserType.RTC_BROWSER_ELECTRON;
+        var version = userAgent.match(/Electron\/([\d.]+)/)[1];
+        logger.info("This appears to be Electron, ver: " + version);
+        return version;
+    }
+    return null;
+}
+
 function detectNWJS (){
     var userAgent = navigator.userAgent;
     if (userAgent.match(/JitsiMeetNW/)) {
     var version;
     var detectors = [
         detectReactNative,
+        detectElectron,
         detectNWJS,
         detectOpera,
         detectChrome,

modules/RTC/RTCUtils.js

             } else if (RTCBrowserType.isChrome() ||
                     RTCBrowserType.isOpera() ||
                     RTCBrowserType.isNWJS() ||
+                    RTCBrowserType.isElectron() ||
                     RTCBrowserType.isReactNative()) {
                 this.peerconnection = webkitRTCPeerConnection;
                 var getUserMedia = navigator.webkitGetUserMedia.bind(navigator);
                 RTCBrowserType.isFirefox() ||
                 RTCBrowserType.isOpera() ||
                 RTCBrowserType.isTemasysPluginUsed()||
-                RTCBrowserType.isNWJS();
+                RTCBrowserType.isNWJS() ||
+                RTCBrowserType.isElectron();
     },
     /**
      * A method to handle stopping of the stream.

modules/RTC/ScreenObtainer.js

                             onFailure(jitsiError);
                     });
             };
+        } else if(RTCBrowserType.isElectron()) {
+            obtainDesktopStream = (options, onSuccess, onFailure) =>
+                window.JitsiMeetElectron.obtainDesktopStream (
+                    streamId =>
+                        onGetStreamResponse({streamId}, onSuccess, onFailure),
+                    err => onFailure(new JitsiTrackError(
+                        JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR, err))
+                );
         } else if (RTCBrowserType.isTemasysPluginUsed()) {
             // XXX Don't require Temasys unless it's to be used because it
             // doesn't run on React Native, for example.
                 return;
             }
             logger.log("Response from extension: ", response);
-            if (response.streamId) {
-                GUM(
-                    ['desktop'],
-                    stream => streamCallback(stream),
-                    failCallback,
-                    { desktopStream: response.streamId });
-            } else {
-                // As noted in Chrome Desktop Capture API:
-                // If user didn't select any source (i.e. canceled the prompt)
-                // then the callback is called with an empty streamId.
-                if(response.streamId === "")
-                {
-                    failCallback(new JitsiTrackError(
-                        JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED));
-                    return;
-                }
-
-                failCallback(new JitsiTrackError(
-                    JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR,
-                    response.error));
-            }
+            onGetStreamResponse(response, streamCallback, failCallback);
         }
     );
 }
     });
 }
 
+/**
+ * Handles response from external application / extension and calls GUM to
+ * receive the desktop streams or reports error.
+ * @param {object} response
+ * @param {string} response.streamId - the streamId for the desktop stream
+ * @param {string} response.error - error to be reported.
+ * @param {Function} onSuccess - callback for success.
+ * @param {Function} onFailure - callback for failure.
+ */
+function onGetStreamResponse(response, onSuccess, onFailure) {
+    if (response.streamId) {
+        GUM(
+            ['desktop'],
+            stream => onSuccess(stream),
+            onFailure,
+            { desktopStream: response.streamId });
+    } else {
+        // As noted in Chrome Desktop Capture API:
+        // If user didn't select any source (i.e. canceled the prompt)
+        // then the callback is called with an empty streamId.
+        if(response.streamId === "")
+        {
+            onFailure(new JitsiTrackError(
+                JitsiTrackErrors.CHROME_EXTENSION_USER_CANCELED));
+            return;
+        }
+
+        onFailure(new JitsiTrackError(
+            JitsiTrackErrors.CHROME_EXTENSION_GENERIC_ERROR,
+            response.error));
+    }
+}
+
 /**
  * Starts the detection of an installed jidesha extension for firefox.
  * @param options supports "desktopSharingFirefoxDisabled",