fix(ScreenObtainer) fix using gDM with old Electron clients

Detect if gDM support has been enabled and fallback to the previous gUM
flow otherwise.

JitsiTrackError.js

     = 'User canceled screen sharing prompt';
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR]
     = 'Unknown error from screensharing';
+TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.SCREENSHARING_NOT_SUPPORTED_ERROR]
+    = 'Not supported';
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.ELECTRON_DESKTOP_PICKER_ERROR]
     = 'Unkown error from desktop picker';
 TRACK_ERROR_TO_MESSAGE_MAP[JitsiTrackErrors.ELECTRON_DESKTOP_PICKER_NOT_FOUND]

JitsiTrackErrors.spec.ts

         NOT_FOUND,
         PERMISSION_DENIED,
         SCREENSHARING_GENERIC_ERROR,
+        SCREENSHARING_NOT_SUPPORTED_ERROR,
         SCREENSHARING_USER_CANCELED,
         TIMEOUT,
         TRACK_IS_DISPOSED,
         expect( NOT_FOUND ).toBe( 'gum.not_found' );
         expect( PERMISSION_DENIED ).toBe( 'gum.permission_denied' );
         expect( SCREENSHARING_GENERIC_ERROR ).toBe( 'gum.screensharing_generic_error' );
+        expect( SCREENSHARING_NOT_SUPPORTED_ERROR ).toBe( 'gdm.screen_sharing_not_supported' );
         expect( SCREENSHARING_USER_CANCELED ).toBe( 'gum.screensharing_user_canceled' );
         expect( TIMEOUT ).toBe( 'gum.timeout' );
         expect( TRACK_IS_DISPOSED ).toBe( 'track.track_is_disposed' );
         expect( JitsiTrackErrors.NOT_FOUND ).toBe( 'gum.not_found' );
         expect( JitsiTrackErrors.PERMISSION_DENIED ).toBe( 'gum.permission_denied' );
         expect( JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR ).toBe( 'gum.screensharing_generic_error' );
+        expect( JitsiTrackErrors.SCREENSHARING_NOT_SUPPORTED_ERROR ).toBe( 'gdm.screen_sharing_not_supported' );
         expect( JitsiTrackErrors.SCREENSHARING_USER_CANCELED ).toBe( 'gum.screensharing_user_canceled' );
         expect( JitsiTrackErrors.TIMEOUT ).toBe( 'gum.timeout' );
         expect( JitsiTrackErrors.TRACK_IS_DISPOSED ).toBe( 'track.track_is_disposed' );

JitsiTrackErrors.ts

      */
     SCREENSHARING_GENERIC_ERROR = 'gum.screensharing_generic_error',
 
+    /**
+     * Error in getDisplayMedia when not supported. Can happen in Electron if no
+     * permission handler was set.
+     */
+    SCREENSHARING_NOT_SUPPORTED_ERROR = 'gdm.screen_sharing_not_supported',
+
     /**
      * An error which indicates that user canceled screen sharing window
      * selection dialog.
 export const NOT_FOUND = JitsiTrackErrors.NOT_FOUND;
 export const PERMISSION_DENIED = JitsiTrackErrors.PERMISSION_DENIED;
 export const SCREENSHARING_GENERIC_ERROR = JitsiTrackErrors.SCREENSHARING_GENERIC_ERROR;
+export const SCREENSHARING_NOT_SUPPORTED_ERROR = JitsiTrackErrors.SCREENSHARING_NOT_SUPPORTED_ERROR;
 export const SCREENSHARING_USER_CANCELED = JitsiTrackErrors.SCREENSHARING_USER_CANCELED;
 export const TIMEOUT = JitsiTrackErrors.TIMEOUT;
 export const TRACK_IS_DISPOSED = JitsiTrackErrors.TRACK_IS_DISPOSED;

modules/RTC/ScreenObtainer.js

         if (!this.obtainStream) {
             logger.info('Desktop sharing disabled');
         }
+
+        this._electronSkipDisplayMedia = false;
     },
 
     /**
     _createObtainStreamMethod() {
         const supportsGetDisplayMedia = browser.supportsGetDisplayMedia();
 
-        if (browser.isElectron() && !this.options.testing?.electronUseGetDisplayMedia) {
+        if (browser.isElectron()) {
             return this.obtainScreenOnElectron;
         } else if (browser.isReactNative() && supportsGetDisplayMedia) {
             return this.obtainScreenFromGetDisplayMediaRN;
      * @param {Object} options - Optional parameters.
      */
     obtainScreenOnElectron(onSuccess, onFailure, options = {}) {
-        if (typeof window.JitsiMeetScreenObtainer?.openDesktopPicker === 'function') {
-            // Detect if we have the fallback option.
-            if (window.JitsiMeetScreenObtainer?.gDMSupported) {
-                return this.obtainScreenFromGetDisplayMedia(onSuccess, onFailure);
-            }
+        if (!this._electronSkipDisplayMedia) {
+            // Fall-back to the old API in case of not supported error. This can happen if
+            // an old Electron SDK is used with a new Jitsi Meet + lib-jitsi-meet version.
+            this.obtainScreenFromGetDisplayMedia(onSuccess, err => {
+                if (err.name === JitsiTrackErrors.SCREENSHARING_NOT_SUPPORTED_ERROR) {
+                    // Make sure we don't recurse infinitely.
+                    this._electronSkipDisplayMedia = true;
+                    this.obtainScreenOnElectron(onSuccess, onFailure);
+                } else {
+                    onFailure(err);
+                }
+            });
+
+            return;
+        }
 
+        // TODO: legacy flow, remove after the Electron SDK supporting gDM has been out for a while.
+        if (typeof window.JitsiMeetScreenObtainer?.openDesktopPicker === 'function') {
             const { desktopSharingFrameRate, desktopSharingResolution, desktopSharingSources } = this.options;
 
             window.JitsiMeetScreenObtainer.openDesktopPicker(
             })
             .catch(error => {
                 const errorDetails = {
-                    errorName: error?.name,
-                    errorMsg: error?.message,
-                    errorStack: error?.stack
+                    errorCode: error.code,
+                    errorName: error.name,
+                    errorMsg: error.message,
+                    errorStack: error.stack
                 };
 
                 logger.warn('getDisplayMedia error', JSON.stringify(constraints), JSON.stringify(errorDetails));
 
-                if (errorDetails.errorMsg?.indexOf('denied by system') !== -1) {
+                if (errorDetails.code === DOMException.NOT_SUPPORTED_ERR) {
+                    // This error is thrown when an Electron client has not set a permissions handler.
+                    errorCallback(new JitsiTrackError(JitsiTrackErrors.SCREENSHARING_NOT_SUPPORTED_ERROR));
+                } else if (errorDetails.errorMsg?.indexOf('denied by system') !== -1) {
                     // On Chrome this is the only thing different between error returned when user cancels
                     // and when no permission was given on the OS level.
                     errorCallback(new JitsiTrackError(JitsiTrackErrors.PERMISSION_DENIED));