ref(tracks): remove duplication in mute/unmute

react/features/base/media/middleware.js

 import { setTrackMuted, TRACK_ADDED } from '../tracks';
 
 import { setAudioMuted, setCameraFacingMode, setVideoMuted } from './actions';
-import { CAMERA_FACING_MODE, MEDIA_TYPE } from './constants';
+import { CAMERA_FACING_MODE } from './constants';
 
 /**
  * Implements the entry point of the middleware of the feature base/media.
     // fired before track gets to state.
     if (track.muted !== muted) {
         track.muted = muted;
-        setTrackMuted(track.jitsiTrack, muted)
-            .catch(error => {
-                console.error(`setTrackMuted(${muted}) failed`, error);
-
-                const setMuted
-                    = track.mediaType === MEDIA_TYPE.AUDIO
-                        ? setAudioMuted
-                        : setVideoMuted;
-
-                // Failed to sync muted state - dispatch rollback action
-                store.dispatch(setMuted(!muted));
-            });
+        setTrackMuted(track.jitsiTrack, muted, store);
     }
 }

react/features/base/tracks/functions.js

 /* global APP */
 
 import JitsiMeetJS, { JitsiTrackEvents } from '../lib-jitsi-meet';
-import { MEDIA_TYPE } from '../media';
+import { MEDIA_TYPE, setAudioMuted, setVideoMuted } from '../media';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * Mutes or unmutes a specific <tt>JitsiLocalTrack</tt>. If the muted state of
  * the specified <tt>track</tt> is already in accord with the specified
- * <tt>muted</tt> value, then does nothing.
+ * <tt>muted</tt> value, then does nothing. In case mute/unmute operation fails
+ * (JitsiLocalTrack Promise is rejected) a rollback action will be dispatched on
+ * the given store. For example if the mute operation fails then the 'unmute'
+ * action will be dispatched to rollback to the previous state in base/media.
  *
  * @param {JitsiLocalTrack} track - The <tt>JitsiLocalTrack</tt> to mute or
  * unmute.
  * @param {boolean} muted - If the specified <tt>track</tt> is to be muted, then
  * <tt>true</tt>; otherwise, <tt>false</tt>.
- * @returns {Promise}
+ * @param {Store} store - The redux store in the context of which the function
+ * is to execute and which will be used to dispatch the rollback action in case
+ * mute/unmute fails.
+* @returns {Promise}
  */
-export function setTrackMuted(track, muted) {
+export function setTrackMuted(track, muted, { dispatch }) {
     if (track.isMuted() === muted) {
         return Promise.resolve();
     }
 
     const f = muted ? 'mute' : 'unmute';
 
-    return track[f]();
+    return track[f]().catch(error => {
+        console.error(`set track ${f} failed`, error);
+
+        const setMuted
+            = track.mediaType === MEDIA_TYPE.AUDIO
+                ? setAudioMuted
+                : setVideoMuted;
+
+        dispatch(setMuted(!muted));
+    });
 }

react/features/base/tracks/middleware.js

     const localTrack = _getLocalTrack(store, mediaType);
 
     if (localTrack) {
-        setTrackMuted(localTrack.jitsiTrack, action.muted)
-            .catch(error => {
-                console.error(`setTrackMuted(${action.muted}) failed`, error);
-
-                const setMuted
-                    = mediaType === MEDIA_TYPE.AUDIO
-                        ? setAudioMuted : setVideoMuted;
-
-                // Failed to modify muted state - dispatch rollback action
-                store.dispatch(setMuted(!action.muted));
-            });
+        setTrackMuted(localTrack.jitsiTrack, action.muted, store);
     }
 }