Consistent naming of functions

Until we make a decision on access modifier hints and adopt a respective
coding style, consistency is king.

react/features/audio-mode/middleware.js

     // The react-native module AudioMode is implemented on iOS at the time of
     // this writing.
     if (AudioMode) {
-        let audioMode;
+        let mode;
 
         switch (action.type) {
         case APP_WILL_MOUNT:
         case CONFERENCE_FAILED:
         case CONFERENCE_LEFT:
-            audioMode = AudioMode.DEFAULT;
+            mode = AudioMode.DEFAULT;
             break;
 
         case CONFERENCE_WILL_JOIN: {
             const conference = store.getState()['features/base/conference'];
 
-            audioMode
+            mode
                 = conference.audioOnly
                     ? AudioMode.AUDIO_CALL
                     : AudioMode.VIDEO_CALL;
         }
 
         default:
-            audioMode = null;
+            mode = null;
             break;
         }
 
-        if (audioMode !== null) {
-            AudioMode.setMode(audioMode).catch(err => {
-                console.error(`Failed to set audio mode ${audioMode}: ${err}`);
-            });
+        if (mode !== null) {
+            AudioMode.setMode(mode)
+                .catch(err =>
+                    console.error(`Failed to set audio mode ${mode}: ${err}`));
         }
     }
 

react/features/base/lib-jitsi-meet/native/RTCPeerConnection.js

 /**
  * Logs at error level.
  *
+ * @private
  * @returns {void}
  */
 function _LOGE(...args) {
  *
  * @param {RTCSessionDescription} sessionDescription - The RTCSessionDescription
  * which specifies the configuration of the remote end of the connection.
+ * @private
+ * @private
  * @returns {Promise}
  */
 function _setRemoteDescription(sessionDescription) {
  *
  * @param {RTCSessionDescription} sdp - The RTCSessionDescription which
  * specifies the configuration of the remote end of the connection.
+ * @private
  * @returns {Promise}
  */
 function _synthesizeIPv6Addresses(sdp) {
  *
  * @param {RTCSessionDescription} sessionDescription - The RTCSessionDescription
  * for which IPv6 addresses will be synthesized.
+ * @private
  * @returns {{
  *     ips: Map,
  *     lines: Array
  * @param {Map} ips - A Map of IPv4 addresses found in the specified
  * sessionDescription to synthesized IPv6 addresses.
  * @param {Array} lines - The lines of the specified sessionDescription.
+ * @private
  * @returns {RTCSessionDescription} A RTCSessionDescription that represents the
  * result of the synthesis of IPv6 addresses.
  */

react/features/base/media/components/native/VideoTrack.js

 
     // eslint-disable-next-line valid-jsdoc
     /**
-     * @inheritdoc
-     *
      * Animate the setting of the video track to be rendered by this instance.
+     *
+     * @inheritdoc
+     * @protected
      */
     _setVideoTrack(videoTrack) {
         // If JitsiTrack instance didn't change, that means some other track's

react/features/base/media/middleware.js

 
     switch (action.type) {
     case CONFERENCE_LEFT:
-        resetInitialMediaState(store);
+        _resetInitialMediaState(store);
         break;
 
     case TRACK_ADDED:
-        action.track.local && syncTrackMutedState(store, action.track);
+        action.track.local && _syncTrackMutedState(store, action.track);
         break;
     }
 
  * Resets initial media state.
  *
  * @param {Store} store - Redux store.
+ * @private
  * @returns {void}
  */
-function resetInitialMediaState(store) {
+function _resetInitialMediaState(store) {
     const { dispatch, getState } = store;
     const state = getState()['features/base/media'];
 
  *
  * @param {Store} store - Redux store.
  * @param {Track} track - Local media track.
+ * @private
  * @returns {void}
  */
-function syncTrackMutedState(store, track) {
+function _syncTrackMutedState(store, track) {
     const state = store.getState()['features/base/media'];
     const muted = state[track.mediaType].muted;
 

react/features/base/media/reducer.js

  * @param {AudioMediaState} state - Media state of local audio.
  * @param {Object} action - Action object.
  * @param {string} action.type - Type of action.
+ * @private
  * @returns {AudioMediaState}
  */
-function audio(state = AUDIO_INITIAL_MEDIA_STATE, action) {
+function _audio(state = AUDIO_INITIAL_MEDIA_STATE, action) {
     switch (action.type) {
     case SET_AUDIO_MUTED:
         return {
  * @param {VideoMediaState} state - Media state of local video.
  * @param {Object} action - Action object.
  * @param {string} action.type - Type of action.
+ * @private
  * @returns {VideoMediaState}
  */
-function video(state = VIDEO_INITIAL_MEDIA_STATE, action) {
+function _video(state = VIDEO_INITIAL_MEDIA_STATE, action) {
     switch (action.type) {
     case SET_CAMERA_FACING_MODE:
         return {
  * @returns {Object}
  */
 ReducerRegistry.register('features/base/media', combineReducers({
-    audio,
-    video
+    audio: _audio,
+    video: _video
 }));

react/features/base/navigator/RouteRegistry.js

          *
          * @private
          */
-        this._routeRegistry = new Set();
+        this._elements = new Set();
     }
 
     /**
         // We use the destructuring operator to 'clone' the route object to
         // prevent modifications from outside (e.g. React Native's Navigator
         // extends it with additional properties).
-        return [ ...this._routeRegistry ].map(r => {
+        return [ ...this._elements ].map(r => {
             return { ...r };
         });
     }
      */
     getRouteByComponent(component) {
         const route
-            = [ ...this._routeRegistry ].find(r => r.component === component);
+            = [ ...this._elements ].find(r => r.component === component);
 
         // We use destructuring operator to 'clone' route object to prevent
         // modifications from outside (e.g. React Native's Navigator extends
      * @returns {void}
      */
     register(route) {
-        if (this._routeRegistry.has(route)) {
+        if (this._elements.has(route)) {
             throw new Error(`Route ${route.component} is registered already!`);
         }
 
-        this._routeRegistry.add(route);
+        this._elements.add(route);
     }
 }
 

react/features/base/participants/reducer.js

  * @param {Participant} action.participant - Information about participant to be
  * added/modified.
  * @param {JitsiConference} action.conference - Conference instance.
+ * @private
  * @returns {Participant|undefined}
  */
-function participant(state, action) {
+function _participant(state, action) {
     switch (action.type) {
     case DOMINANT_SPEAKER_CHANGED:
         // Only one dominant speaker is allowed.
 ReducerRegistry.register('features/base/participants', (state = [], action) => {
     switch (action.type) {
     case PARTICIPANT_JOINED:
-        return [ ...state, participant(undefined, action) ];
+        return [ ...state, _participant(undefined, action) ];
 
     case PARTICIPANT_LEFT:
         return state.filter(p => p.id !== action.participant.id);
     case PARTICIPANT_ID_CHANGED:
     case PARTICIPANT_UPDATED:
     case PIN_PARTICIPANT:
-        return state.map(p => participant(p, action));
+        return state.map(p => _participant(p, action));
 
     default:
         return state;

react/features/base/redux/MiddlewareRegistry.js

         /**
          * The set of registered middleware.
          */
-        this.middlewareRegistry = new Set();
+        this._elements = new Set();
     }
 
     /**
      */
     applyMiddleware(...additional) {
         return applyMiddleware(
-            ...this.middlewareRegistry,
+            ...this._elements,
             ...additional
         );
     }
      * @returns {void}
      */
     register(middleware) {
-        this.middlewareRegistry.add(middleware);
+        this._elements.add(middleware);
     }
 }
 

react/features/base/redux/ReducerRegistry.js

          * The set of registered reducers, keyed based on the field each reducer
          * will manage.
          */
-        this.reducerRegistry = {};
+        this._elements = {};
     }
 
     /**
      */
     combineReducers(additional = {}) {
         return combineReducers({
-            ...this.reducerRegistry,
+            ...this._elements,
             ...additional
         });
     }
      * @returns {void}
      */
     register(name, reducer) {
-        this.reducerRegistry[name] = reducer;
+        this._elements[name] = reducer;
     }
 }
 

react/features/base/tracks/actions.js

                     .map(t => t.jitsiTrack)));
 }
 
-/**
- * Returns true if the provided JitsiTrack should be rendered as a mirror.
- *
- * We only want to show a video in mirrored mode when:
- * 1) The video source is local, and not remote.
- * 2) The video source is a camera, not a desktop (capture).
- * 3) The camera is capturing the user, not the environment.
- *
- * TODO Similar functionality is part of lib-jitsi-meet. This function should be
- * removed after https://github.com/jitsi/lib-jitsi-meet/pull/187 is merged.
- *
- * @param {(JitsiLocalTrack|JitsiRemoteTrack)} track - JitsiTrack instance.
- * @private
- * @returns {boolean}
- */
-function _shouldMirror(track) {
-    return (
-        track
-            && track.isLocal()
-            && track.isVideoTrack()
-
-            // XXX Type of the return value of
-            // JitsiLocalTrack#getCameraFacingMode() happens to be named
-            // CAMERA_FACING_MODE as well, it's defined by lib-jitsi-meet. Note
-            // though that the type of the value on the right side of the
-            // equality check is defined by jitsi-meet-react. The type
-            // definitions are surely compatible today but that may not be the
-            // case tomorrow.
-            && track.getCameraFacingMode() === CAMERA_FACING_MODE.USER
-            && !track.isScreenSharing()
-    );
-}
-
 /**
  * Create an action for when a new track has been signaled to be added to the
  * conference.
  * through.
  * @param {MEDIA_TYPE} mediaType - The <tt>MEDIA_TYPE</tt> of the first
  * <tt>JitsiLocalTrack</tt> to be returned.
+ * @private
  * @returns {JitsiLocalTrack} The first <tt>JitsiLocalTrack</tt>, if any, in the
  * specified <tt>tracks</tt> of the specified <tt>mediaType</tt>.
  */
     };
 }
 
+/**
+ * Returns true if the provided JitsiTrack should be rendered as a mirror.
+ *
+ * We only want to show a video in mirrored mode when:
+ * 1) The video source is local, and not remote.
+ * 2) The video source is a camera, not a desktop (capture).
+ * 3) The camera is capturing the user, not the environment.
+ *
+ * TODO Similar functionality is part of lib-jitsi-meet. This function should be
+ * removed after https://github.com/jitsi/lib-jitsi-meet/pull/187 is merged.
+ *
+ * @param {(JitsiLocalTrack|JitsiRemoteTrack)} track - JitsiTrack instance.
+ * @private
+ * @returns {boolean}
+ */
+function _shouldMirror(track) {
+    return (
+        track
+            && track.isLocal()
+            && track.isVideoTrack()
+
+            // XXX Type of the return value of
+            // JitsiLocalTrack#getCameraFacingMode() happens to be named
+            // CAMERA_FACING_MODE as well, it's defined by lib-jitsi-meet. Note
+            // though that the type of the value on the right side of the
+            // equality check is defined by jitsi-meet-react. The type
+            // definitions are surely compatible today but that may not be the
+            // case tomorrow.
+            && track.getCameraFacingMode() === CAMERA_FACING_MODE.USER
+            && !track.isScreenSharing()
+    );
+}
+
 /**
  * Set new local tracks replacing any existing tracks that were previously
  * available. Currently only one audio and one video local tracks are allowed.
  *
  * @param {(JitsiLocalTrack|JitsiRemoteTrack)[]} [newTracks=[]] - List of new
  * media tracks.
+ * @private
  * @returns {Function}
  */
 function _updateLocalTracks(newTracks = []) {

react/features/film-strip/components/Thumbnail.js

         this._onClick = this._onClick.bind(this);
     }
 
-    /**
-     * Handles click/tap event on the thumbnail.
-     *
-     * @returns {void}
-     */
-    _onClick() {
-        const { dispatch, participant } = this.props;
-
-        // TODO The following currently ignores interfaceConfig.filmStripOnly.
-        dispatch(pinParticipant(participant.pinned ? null : participant.id));
-    }
-
     /**
      * Implements React's {@link Component#render()}.
      *
             </Container>
         );
     }
+
+    /**
+     * Handles click/tap event on the thumbnail.
+     *
+     * @returns {void}
+     */
+    _onClick() {
+        const { dispatch, participant } = this.props;
+
+        // TODO The following currently ignores interfaceConfig.filmStripOnly.
+        dispatch(pinParticipant(participant.pinned ? null : participant.id));
+    }
 }
 
 /**

react/features/wake-lock/middleware.js

 
         // TODO(saghul): Implement audio-only mode.
         if (!state.audioOnly) {
-            setWakeLock(true);
+            _setWakeLock(true);
         }
         break;
     }
 
     case CONFERENCE_FAILED:
     case CONFERENCE_LEFT:
-        setWakeLock(false);
+        _setWakeLock(false);
         break;
     }
 
  *
  * @param {boolean} wakeLock - True to active the wake lock or false to
  * deactivate it.
+ * @private
  * @returns {void}
  */
-function setWakeLock(wakeLock) {
+function _setWakeLock(wakeLock) {
     if (wakeLock) {
         KeepAwake.activate();
     } else {