ref(TPCUtils): don't modify encoding.active

...in setMediaTransferActive. The sender video constraints
are controlling the 'encoding.active' flag and this code
would interfere. It's right now not used anyway as P2P is
disabled in the unified mode. If this modification is
necessary we'll add it back when working on unified P2P
in such a way that will play nicely with the sender constraints code.

modules/RTC/TPCUtils.js

     * the connection should be kept alive.
     * @param {boolean} active - true to enable audio media transmission or
     * false to disable.
-    * @returns {Promise<void>} - resolved when done.
+    * @returns {void}
     */
     setAudioTransferActive(active) {
-        return this.setMediaTransferActive('audio', active);
+        this.setMediaTransferActive('audio', active);
     }
 
     /**
      * @param {String} mediaType - 'audio' or 'video'
      * @param {boolean} active - true to enable media transmission or false
      * to disable.
-     * @returns {Promise<void>} - resolved when done.
+     * @returns {void}
      */
     setMediaTransferActive(mediaType, active) {
         const transceivers = this.pc.peerconnection.getTransceivers()
             .filter(t => t.receiver && t.receiver.track && t.receiver.track.kind === mediaType);
         const localTracks = this.pc.getLocalTracks(mediaType);
 
-        const setParamPromises = [];
-
-        if (active) {
-            transceivers.forEach(transceiver => {
+        transceivers.forEach(transceiver => {
+            if (active) {
                 if (localTracks.length) {
+                    // FIXME should adjust only the direction of the local sender or FF will fall into renegotiate loop
                     transceiver.direction = 'sendrecv';
-                    const parameters = transceiver.sender.getParameters();
-
-                    if (parameters && parameters.encodings && parameters.encodings.length) {
-                        parameters.encodings.forEach(encoding => {
-                            encoding.active = true;
-                        });
-                        setParamPromises.push(transceiver.sender.setParameters(parameters));
-                    }
                 } else {
                     transceiver.direction = 'recvonly';
                 }
-            });
-        } else {
-            transceivers.forEach(transceiver => {
+            } else {
                 transceiver.direction = 'inactive';
-            });
-        }
-
-        return Promise.all(setParamPromises);
+            }
+        });
     }
 
     /**
     * the connection should be kept alive.
     * @param {boolean} active - true to enable video media transmission or
     * false to disable.
-    * @returns {Promise<void>} - resolved when done.
+    * @returns {void}
     */
     setVideoTransferActive(active) {
-        return this.setMediaTransferActive('video', active);
+        this.setMediaTransferActive('video', active);
     }
 }

modules/RTC/TraceablePeerConnection.js

  */
 TraceablePeerConnection.prototype.setAudioTransferActive = function(active) {
     logger.debug(`${this} audio transfer active: ${active}`);
-    if (browser.usesUnifiedPlan()) {
-        return this.tpcUtils.setAudioTransferActive(active)
-            .then(() => false);
-    }
     const changed = this.audioTransferActive !== active;
 
     this.audioTransferActive = active;
 
+    if (browser.usesUnifiedPlan()) {
+        this.tpcUtils.setAudioTransferActive(active);
+
+        // false means no renegotiation up the chain which is not needed in the Unified mode
+        return false;
+    }
+
     return changed;
 };
 
  */
 TraceablePeerConnection.prototype.setVideoTransferActive = function(active) {
     logger.debug(`${this} video transfer active: ${active}`);
-    if (browser.usesUnifiedPlan()) {
-        return this.tpcUtils.setVideoTransferActive(active)
-            .then(() => false);
-    }
     const changed = this.videoTransferActive !== active;
 
     this.videoTransferActive = active;
 
+    if (browser.usesUnifiedPlan()) {
+        this.tpcUtils.setVideoTransferActive(active);
+
+        // false means no renegotiation up the chain which is not needed in the Unified mode
+        return false;
+    }
+
     return changed;
 };