feat: restart Jingle session on ICE failed

If ICE fails will set the special request restart attribute
in the 'session-terminate' sent to Jicofo in order to restart
the Jingle session.

modules/connectivity/IceFailedHandling.js

      * @returns {void}
      */
     _actOnIceFailed() {
-        if (!this._conference.options.config.enableIceRestart) {
+        const { enableIceRestart } = this._conference.options.config;
+        const explicitlyDisabled = typeof enableIceRestart !== 'undefined' && !enableIceRestart;
+        const supportsRestartByTerminate = this._conference.room.supportsRestartByTerminate();
+        const useTerminateForRestart = supportsRestartByTerminate && !enableIceRestart;
+
+        logger.info('ICE failed,'
+            + ` enableIceRestart: ${enableIceRestart},`
+            + ` supports restart by terminate: ${supportsRestartByTerminate}`);
+
+        if (explicitlyDisabled || (!enableIceRestart && !supportsRestartByTerminate)) {
             logger.info('ICE failed, but ICE restarts are disabled');
             this._conference.eventEmitter.emit(
                 JitsiConferenceEvents.CONFERENCE_FAILED,
         } else if (jvbConnIceState === 'connected') {
             logger.info('ICE connection restored - not sending ICE failed');
         } else {
-            logger.info(`Sending ICE failed - the connection has not recovered: ${jvbConnIceState}`);
-            jvbConnection.sendIceFailedNotification();
+            logger.info('Sending ICE failed - the connection did not recover, '
+                + `ICE state: ${jvbConnIceState}, `
+                + `use 'session-terminate': ${useTerminateForRestart}`);
+            if (useTerminateForRestart) {
+                this._conference.jvbJingleSession.terminate(
+                    () => {
+                        logger.info('session-terminate for ice restart - done');
+                    },
+                    error => {
+                        logger.error(`session-terminate for ice restart - error: ${error.message}`);
+                    }, {
+                        reason: 'connectivity-error',
+                        reasonDescription: 'ICE FAILED',
+                        requestRestart: true,
+                        sendSessionTerminate: true
+                    });
+            } else {
+                this._conference.jvbJingleSession.sendIceFailedNotification();
+            }
         }
     }
 

modules/connectivity/IceFailedHandling.spec.js

             // eslint-disable-next-line no-empty-function
             emit: () => { }
         };
+        mockConference.room = {
+            supportsRestartByTerminate: () => false
+        };
         mockConference.xmpp = {
             ping: () => Promise.resolve()
         };
                 });
         });
     });
+    describe('if Jingle session restarts are supported', () => {
+        let sendSessionTerminateSpy;
+
+        beforeEach(() => {
+            mockConference.options.config.enableIceRestart = undefined;
+            mockConference.room = {
+                supportsRestartByTerminate: () => true
+            };
+            mockConference.jvbJingleSession = {
+                getIceConnectionState: () => 'failed',
+                // eslint-disable-next-line no-empty-function
+                terminate: () => { }
+            };
+            sendSessionTerminateSpy = spyOn(mockConference.jvbJingleSession, 'terminate');
+        });
+        it('send "session-terminate" with the request restart attribute', () => {
+            iceFailedHandling.start();
+
+            return nextTick() // tick for ping
+                .then(() => nextTick(2500)) // tick for ice timeout
+                .then(() => {
+                    expect(sendSessionTerminateSpy).toHaveBeenCalledWith(
+                        jasmine.any(Function),
+                        jasmine.any(Function), {
+                            reason: 'connectivity-error',
+                            reasonDescription: 'ICE FAILED',
+                            requestRestart: true,
+                            sendSessionTerminate: true
+                        });
+                });
+        });
+    });
 });

modules/xmpp/ChatRoom.js

         this.focusMucJid = from;
 
         logger.info(`Ignore focus: ${from}, real JID: ${mucJid}`);
+        this.xmpp.caps.getFeatures(mucJid, 15000).then(features => {
+            this.focusFeatures = features;
+            logger.info(`Jicofo supports restart by terminate: ${this.supportsRestartByTerminate()}`);
+        }, error => {
+            logger.error('Failed to discover Jicofo features', error && error.message);
+        });
     }
 
     /**
         this.participantPropertyListener = listener;
     }
 
+    /**
+     * Checks if Jicofo supports restarting Jingle session after 'session-terminate'.
+     * @returns {boolean}
+     */
+    supportsRestartByTerminate() {
+        return this.focusFeatures
+            ? this.focusFeatures.has('https://jitsi.org/meet/jicofo/terminate-restart')
+            : false;
+    }
+
     /**
      *
      * @param node