fix: Drop caps handling (#1495)

* feat: Drops unused code about handling incoming caps changes.

* fix: Drop using private fields outside JitsiParticipant.

JitsiConference.js

     const participant
         = new JitsiParticipant(jid, this, nick, isHidden, statsID, status, identity);
 
-    participant._role = role;
-    participant._botType = botType;
-    participant._features = features || new Set();
+    participant.setRole(role);
+    participant.setBotType(botType);
+    participant.setFeatures(features);
 
     this.participants[id] = participant;
     this.eventEmitter.emit(
     const botParticipant = peers.find(p => p.getJid() === jid);
 
     if (botParticipant) {
-        botParticipant._botType = botType;
+        botParticipant.setBotType(botType);
         const id = Strophe.getResourceFromJid(jid);
 
         this.eventEmitter.emit(
     // poltergeist mode this is the moment when the poltergeist had exited and
     // the real participant had already replaced it.
     // In this case we can check and try p2p
-    if (!botParticipant._botType) {
+    if (!botParticipant.getBotType()) {
         this._maybeStartOrStopP2P();
     }
 };
     if (!participant) {
         return;
     }
-    participant._role = role;
+    participant.setRole(role);
     this.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED, id, role);
 };
 
 JitsiConference.prototype._shouldBeInP2PMode = function() {
     const peers = this.getParticipants();
     const peerCount = peers.length;
-    const hasBotPeer = peers.find(p => p._botType === 'poltergeist' || p._features.has(FEATURE_JIGASI)) !== undefined;
+    const hasBotPeer = peers.find(p => p.getBotType() === 'poltergeist' || p.hasFeature(FEATURE_JIGASI)) !== undefined;
     const shouldBeInP2P = peerCount === 1 && !hasBotPeer;
 
     logger.debug(`P2P? peerCount: ${peerCount}, hasBotPeer: ${hasBotPeer} => ${shouldBeInP2P}`);

JitsiConferenceEventManager.js

         const participant = conference.getParticipantById(Strophe.getResourceFromJid(from));
 
         if (participant) {
-            participant._features = features || new Set();
+            participant.setFeatures(features);
             conference.eventEmitter.emit(JitsiConferenceEvents.PARTCIPANT_FEATURES_CHANGED, participant);
         }
     };

JitsiParticipant.js

 
-import { getLogger } from 'jitsi-meet-logger';
 import { Strophe } from 'strophe.js';
 
 
 import * as JitsiConferenceEvents from './JitsiConferenceEvents';
 import { ParticipantConnectionStatus }
     from './modules/connectivity/ParticipantConnectionStatus';
-import { ERROR_FEATURE_VERSION_MISMATCH } from './modules/xmpp/Caps';
 import * as MediaType from './service/RTC/MediaType';
 
-const logger = getLogger(__filename);
-
 /**
  * Represents a participant in (i.e. a member of) a conference.
  */
         return this._role;
     }
 
+    /**
+     * Sets a new participant role.
+     * @param {String} newRole - the new role.
+     */
+    setRole(newRole) {
+        this._role = newRole;
+    }
+
     /**
      *
      */
     }
 
     /**
-     * Returns a set with the features for the participant.
-     * @param {int} timeout the timeout in ms for reply from the participant.
-     * @returns {Promise<Set<String>, Error>}
+     * Checks current set features.
+     * @param {String} feature - the feature to check.
+     * @return {boolean} <tt>true</tt> if this <tt>participant</tt> contains the
+     * <tt>feature</tt>.
      */
-    queryFeatures(timeout = 5000) {
-        if (this._getFeaturesPromise) {
-            return this._getFeaturesPromise;
-        }
-
-        this._getFeaturesPromise = this._conference.xmpp.caps.getFeatures(this._jid, timeout)
-            .catch(error => {
-                // Retry on feature version mismatch
-                if (error === ERROR_FEATURE_VERSION_MISMATCH) {
-                    return this._conference.xmpp.caps.getFeatures(this._jid, timeout);
-                }
-
-                logger.warn(`Failed to discover features of ${this._jid}`, error);
-
-                return Promise.reject(error);
-            });
-
-        return this._getFeaturesPromise
-            .then(result => {
-                this._getFeaturesPromise = undefined;
-
-                return result;
-            }, error => {
-                this._getFeaturesPromise = undefined;
+    hasFeature(feature) {
+        return this._features.has(feature);
+    }
 
-                throw error;
-            });
+    /**
+     * Set new features.
+     * @param {Set<String>|undefined} newFeatures - Sets new features.
+     */
+    setFeatures(newFeatures) {
+        this._features = newFeatures || new Set();
     }
 
     /**
     getBotType() {
         return this._botType;
     }
+
+    /**
+     * Sets the bot type for the participant.
+     * @param {String} newBotType - The new bot type to set.
+     */
+    setBotType(newBotType) {
+        this._botType = newBotType;
+    }
 }

modules/xmpp/Caps.js

 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 import Listenable from '../util/Listenable';
 
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-
 /**
  * The property
  */
 const IDENTITY_PROPERTIES_FOR_COMPARE = [ 'category', 'type', 'lang' ];
 const HASH = 'sha-1';
 
-export const ERROR_FEATURE_VERSION_MISMATCH = 'Feature version mismatch';
-
 /**
  *
  * @param a
                 + '(disco plugin is required)!');
         }
 
-        this.versionToCapabilities = Object.create(null);
-        this.jidToVersion = Object.create(null);
         this.version = '';
         this.rooms = new Set();
 
 
         Strophe.addNamespace('CAPS', 'http://jabber.org/protocol/caps');
         this.disco.addFeature(Strophe.NS.CAPS);
-        connection.addHandler(this._handleCaps.bind(this), Strophe.NS.CAPS);
-
-        this._onMucMemberLeft = this._removeJidToVersionEntry.bind(this);
     }
 
     /**
         }
     }
 
-    /**
-     * Returns a set with the features for a participant.
-     * @param {String} jid the jid of the participant
-     * @param {int} timeout the timeout in ms for reply from the participant.
-     * @returns {Promise<Set<String>, Error>}
-     */
-    getFeatures(jid, timeout = 5000) {
-        const user
-            = jid in this.jidToVersion ? this.jidToVersion[jid] : null;
-
-        if (!user || !(user.version in this.versionToCapabilities)) {
-            const node = user ? `${user.node}#${user.version}` : null;
-
-            return this._getDiscoInfo(jid, node, timeout)
-                .then(({ features, identities }) => {
-                    if (user) {
-                        const sha = generateSha(
-                            Array.from(identities),
-                            Array.from(features)
-                        );
-                        const receivedNode = `${user.node}#${sha}`;
-
-                        if (receivedNode === node) {
-                            this.versionToCapabilities[receivedNode] = features;
-
-                            return features;
-                        }
-
-                        // Check once if it has been cached asynchronously.
-                        if (this.versionToCapabilities[receivedNode]) {
-                            return this.versionToCapabilities[receivedNode];
-                        }
-
-                        logger.error(`Expected node ${node} but received ${
-                            receivedNode}`);
-
-                        return Promise.reject(ERROR_FEATURE_VERSION_MISMATCH);
-                    }
-
-                    return features;
-                });
-        }
-
-        return Promise.resolve(this.versionToCapabilities[user.version]);
-    }
-
     /**
      * Returns a set with the features for a host.
      * @param {String} jid the jid of the host
      */
     _addChatRoom(room) {
         this.rooms.add(room);
-        room.addListener(XMPPEvents.MUC_MEMBER_LEFT, this._onMucMemberLeft);
         this._fixChatRoomPresenceMap(room);
 
         this._updateRoomWithExternalFeatures(room);
      */
     _removeChatRoom(room) {
         this.rooms.delete(room);
-        room.removeListener(XMPPEvents.MUC_MEMBER_LEFT, this._onMucMemberLeft);
     }
 
     /**
 
         this._notifyVersionChanged();
     }
-
-    /**
-     * Parses the "c" xml node from presence.
-     * @param {DOMElement} stanza the presence packet
-     */
-    _handleCaps(stanza) {
-        const from = stanza.getAttribute('from');
-        const caps = stanza.querySelector('c');
-        const version = caps.getAttribute('ver');
-        const node = caps.getAttribute('node');
-        const oldVersion = this.jidToVersion[from];
-
-        this.jidToVersion[from] = { version,
-            node };
-        if (oldVersion && oldVersion.version !== version) {
-            // We should be receiving update of features in the presence <feature> node
-            // and ignore the caps version for disco-info
-            logger.warn(`Received update in caps for ${from}`);
-        }
-
-        // return true to not remove the handler from Strophe
-        return true;
-    }
-
-    /**
-     * Removes entry from this.jidToVersion map.
-     * @param {String} jid the jid to be removed.
-     */
-    _removeJidToVersionEntry(jid) {
-        if (jid in this.jidToVersion) {
-            delete this.jidToVersion[jid];
-        }
-    }
 }