Fix interface_config.js/interfaceConfig overriding

It got broken while rewriting the Web toolbar in React Toolbox. There is
a problem with the toolbars and how we construct the intialState of the
buttons. The _getInitialState() in the toolbox reducer gets the list of
buttons from interfaceConfig, but in fact interfaceConfig is meant to be
overriden in several very important cases. One of the cases being the
external API, which we use in several projects in production.

react/features/toolbox/actionTypes.js

  */
 export const CLEAR_TOOLBOX_TIMEOUT = Symbol('CLEAR_TOOLBOX_TIMEOUT');
 
+/**
+ * The type of the action which sets the default toolbar buttons of the Toolbox.
+ *
+ * {
+ *     type: SET_DEFAULT_TOOLBOX_BUTTONS,
+ *     primaryToolbarButtons: Map,
+ *     secondaryToolbarButtons: Map
+ * }
+ */
+export const SET_DEFAULT_TOOLBOX_BUTTONS
+    = Symbol('SET_DEFAULT_TOOLBOX_BUTTONS');
+
 /**
  * The type of the action which sets the permanent visibility of the Toolbox.
  *

react/features/toolbox/actions.native.js

 
 import {
     CLEAR_TOOLBOX_TIMEOUT,
+    SET_DEFAULT_TOOLBOX_BUTTONS,
     SET_TOOLBOX_ALWAYS_VISIBLE,
     SET_SUBJECT,
     SET_SUBJECT_SLIDE_IN,
     SET_TOOLBOX_TIMEOUT_MS,
     SET_TOOLBOX_VISIBLE
 } from './actionTypes';
+import { getDefaultToolboxButtons } from './functions';
 
 /**
  * Event handler for local raise hand changed event.
     };
 }
 
-/**
- * Signals that always visible toolbars value should be changed.
- *
- * @param {boolean} alwaysVisible - Value to be set in redux store.
- * @returns {{
- *     type: SET_TOOLBOX_ALWAYS_VISIBLE,
- *     alwaysVisible: boolean
- * }}
- */
-export function setToolboxAlwaysVisible(alwaysVisible: boolean): Object {
-    return {
-        type: SET_TOOLBOX_ALWAYS_VISIBLE,
-        alwaysVisible
-    };
-}
-
 /**
  * Enables/disables audio toolbar button.
  *
     };
 }
 
+/**
+ * Sets the default toolbar buttons of the Toolbox.
+ *
+ * @returns {{
+ *     type: SET_DEFAULT_TOOLBOX_BUTTONS,
+ *     primaryToolbarButtons: Map,
+ *     secondaryToolbarButtons: Map
+ * }}
+ */
+export function setDefaultToolboxButtons(): Object {
+    return {
+        type: SET_DEFAULT_TOOLBOX_BUTTONS,
+        ...getDefaultToolboxButtons()
+    };
+}
+
 /**
  * Signals that value of conference subject should be changed.
  *
     };
 }
 
+/**
+ * Signals that always visible toolbars value should be changed.
+ *
+ * @param {boolean} alwaysVisible - Value to be set in redux store.
+ * @returns {{
+ *     type: SET_TOOLBOX_ALWAYS_VISIBLE,
+ *     alwaysVisible: boolean
+ * }}
+ */
+export function setToolboxAlwaysVisible(alwaysVisible: boolean): Object {
+    return {
+        type: SET_TOOLBOX_ALWAYS_VISIBLE,
+        alwaysVisible
+    };
+}
+
 /* eslint-disable flowtype/space-before-type-colon */
 
 /**

react/features/toolbox/components/Toolbox.web.js

 
 import UIEvents from '../../../../service/UI/UIEvents';
 
-import { setToolboxAlwaysVisible } from '../actions';
+import {
+    setDefaultToolboxButtons,
+    setToolboxAlwaysVisible
+} from '../actions';
 import {
     abstractMapStateToProps,
     showCustomToolbarPopup
      * @static
      */
     static propTypes = {
+        /**
+         * Handler dispatching setting default buttons action.
+         */
+        _setDefaultToolboxButtons: React.PropTypes.func,
+
         /**
          * Handler dispatching reset always visible toolbox action.
          */
         APP.UI.addListener(
             UIEvents.SHOW_CUSTOM_TOOLBAR_BUTTON_POPUP,
             showCustomToolbarPopup);
+
+        // FIXME The redux action SET_DEFAULT_TOOLBOX_BUTTONS and related source
+        // code such as the redux action creator setDefaultToolboxButtons and
+        // _setDefaultToolboxButtons were introduced to solve the following bug
+        // in the implementation of features/toolbar at the time of this
+        // writing: getDefaultToolboxButtons uses interfaceConfig which is not
+        // in the redux store at the time of this writing yet interfaceConfig is
+        // modified after getDefaultToolboxButtons is called.
+        // SET_DEFAULT_TOOLBOX_BUTTONS represents/implements an explicit delay
+        // of the invocation of getDefaultToolboxButtons until, heuristically,
+        // all existing changes to interfaceConfig have been applied already in
+        // our known execution paths.
+        this.props._setDefaultToolboxButtons();
     }
 
     /**
  *
  * @param {Function} dispatch - Redux action dispatcher.
  * @returns {{
+ *     _setDefaultToolboxButtons: Function,
  *     _setToolboxAlwaysVisible: Function
  * }}
  * @private
  */
 function _mapDispatchToProps(dispatch: Function): Object {
     return {
+        /**
+         * Dispatches a (redux) action to set the default toolbar buttons.
+         *
+         * @returns {Object} Dispatched action.
+         */
+        _setDefaultToolboxButtons() {
+            dispatch(setDefaultToolboxButtons());
+        },
 
         /**
-         * Dispatches an action resetting always visible toolbox.
+         * Dispatches a (redux) action to reset the permanent visibility of
+         * the Toolbox.
          *
          * @returns {Object} Dispatched action.
          */

react/features/toolbox/functions.js

     };
 }
 
+/* eslint-disable flowtype/space-before-type-colon */
+
 /**
  * Takes toolbar button props and maps them to HTML attributes to set.
  *
  * @param {Object} props - Props set to the React component.
  * @returns {MapOfAttributes}
  */
-export function getButtonAttributesByProps(props: Object): MapOfAttributes {
-    const classNames = [ ...props.classNames ];
+export function getButtonAttributesByProps(props: Object = {})
+        : MapOfAttributes {
+    let classNames = props.classNames;
+
+    if (classNames) {
+        // XXX Make sure to not modify props.classNames because that'd be bad
+        // practice.
+        classNames = [ ...classNames ];
+    }
 
     props.toggled && classNames.push('toggled');
     props.unclickable && classNames.push('unclickable');
     return result;
 }
 
+/* eslint-enable flowtype/space-before-type-colon */
+
 /**
- * Returns object containing default buttons for the primary and secondary
- * toolbars.
+ * Returns an object which contains the default buttons for the primary and
+ * secondary toolbars.
  *
  * @returns {Object}
  */
-export function getDefaultToolbarButtons(): Object {
+export function getDefaultToolboxButtons(): Object {
     let toolbarButtons = {
         primaryToolbarButtons: new Map(),
         secondaryToolbarButtons: new Map()

react/features/toolbox/reducer.js

 
 import {
     CLEAR_TOOLBOX_TIMEOUT,
+    SET_DEFAULT_TOOLBOX_BUTTONS,
     SET_TOOLBOX_ALWAYS_VISIBLE,
     SET_SUBJECT,
     SET_SUBJECT_SLIDE_IN,
     SET_TOOLBOX_TIMEOUT_MS,
     SET_TOOLBOX_VISIBLE
 } from './actionTypes';
-import { getDefaultToolbarButtons } from './functions';
 
 declare var interfaceConfig: Object;
 
     }
 
     return {
-        ...getDefaultToolbarButtons(),
-
         /**
          * The indicator which determines whether the Toolbox should always be
          * visible.
          */
         hovered: false,
 
+        /**
+         * A Map of the default buttons of the PrimaryToolbar.
+         *
+         * @type {Map}
+         */
+        primaryToolbarButtons: new Map(),
+
+        /**
+         * A Map of the default buttons of the SecondaryToolbar.
+         *
+         * @type {Map}
+         */
+        secondaryToolbarButtons: new Map(),
+
         /**
          * The text of the conference subject.
          *
                 timeoutID: undefined
             };
 
+        case SET_DEFAULT_TOOLBOX_BUTTONS: {
+            const { primaryToolbarButtons, secondaryToolbarButtons } = action;
+
+            return {
+                ...state,
+                primaryToolbarButtons,
+                secondaryToolbarButtons
+            };
+        }
+
         case SET_TOOLBOX_ALWAYS_VISIBLE:
             return {
                 ...state,
  * @private
  * @returns {Object}
  */
-function _setButton(state, { buttonName, button }): Object {
-    const {
-        primaryToolbarButtons,
-        secondaryToolbarButtons
-    } = state;
+function _setButton(state, { button, buttonName }): Object {
+    const { primaryToolbarButtons, secondaryToolbarButtons } = state;
     let selectedButton = primaryToolbarButtons.get(buttonName);
     let place = 'primaryToolbarButtons';