fix(localStorage): exception when disabled.

connection.js

 /* global APP, JitsiMeetJS, config */
 
+import { jitsiLocalStorage } from 'js-utils';
+
 import AuthHandler from './modules/UI/authentication/AuthHandler';
-import jitsiLocalStorage from './modules/util/JitsiLocalStorage';
 
 import {
     connectionEstablished,

modules/UI/util/MessageHandler.js

 /* global $, APP */
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
-import jitsiLocalStorage from '../../util/JitsiLocalStorage';
+import { jitsiLocalStorage } from 'js-utils';
 
 import {
     NOTIFICATION_TIMEOUT,

modules/util/JitsiLocalStorage.js

-import Logger from 'jitsi-meet-logger';
-
-const logger = Logger.getLogger(__filename);
-
-/**
- * Dummy implementation of Storage interface with empty methods.
- */
-class DummyLocalStorage {
-    /* eslint-disable no-empty-function */
-    /**
-     * Empty function
-     */
-    getItem() { }
-
-    /**
-     * Empty function
-     */
-    setItem() { }
-
-    /**
-     * Empty function
-     */
-    removeItem() { }
-    /* eslint-enable no-empty-function */
-}
-
-/**
- * Wrapper class for browser's local storage object.
- */
-class JitsiLocalStorage extends DummyLocalStorage {
-    /**
-     * @constructor
-     * @param {Storage} storage browser's local storage object.
-     */
-    constructor() {
-        super();
-        let storage;
-
-        try {
-            storage = window.localStorage;
-        } catch (error) {
-            logger.error(error);
-        }
-        this.storage = storage || new DummyLocalStorage();
-    }
-
-    /**
-     * Returns that passed key's value.
-     * @param {string} keyName the name of the key you want to retrieve
-     * the value of.
-     * @returns {String|null} the value of the key. If the key does not exist,
-     * null is returned.
-     */
-    getItem(keyName) {
-        return this.storage.getItem(keyName);
-    }
-
-    /**
-     * Adds a key to the storage, or update key's value if it already exists.
-     * @param {string} keyName the name of the key you want to create/update.
-     * @param {string} keyValue the value you want to give the key you are
-     * creating/updating.
-     */
-    setItem(keyName, keyValue) {
-        return this.storage.setItem(keyName, keyValue);
-    }
-
-    /**
-     * Remove a key from the storage.
-     * @param {string} keyName the name of the key you want to remove.
-     */
-    removeItem(keyName) {
-        return this.storage.removeItem(keyName);
-    }
-}
-
-export default new JitsiLocalStorage();

package-lock.json

       "integrity": "sha1-mGbfOVECEw449/mWvOtlRDIJwls="
     },
     "js-utils": {
-      "version": "github:jitsi/js-utils#df68966e3c65b5c57fcd2670da1326a2c77518d1",
-      "from": "github:jitsi/js-utils#df68966e3c65b5c57fcd2670da1326a2c77518d1",
+      "version": "github:jitsi/js-utils#efb02828785b2b532097d96f4b32a101847ba58b",
+      "from": "github:jitsi/js-utils#efb02828785b2b532097d96f4b32a101847ba58b",
       "requires": {
         "bowser": "2.7.0",
         "js-md5": "0.7.3",
         "strophejs-plugin-disco": "0.0.2",
         "strophejs-plugin-stream-management": "github:jitsi/strophejs-plugin-stream-management#e719a02b4f83856c1530882084a4b048ee622d45",
         "webrtc-adapter": "7.5.0"
+      },
+      "dependencies": {
+        "js-md5": {
+          "version": "0.7.3",
+          "resolved": "https://registry.npmjs.org/js-md5/-/js-md5-0.7.3.tgz",
+          "integrity": "sha512-ZC41vPSTLKGwIRjqDh8DfXoCrdQIyBgspJVPXHBGu4nZlAEvG3nf+jO9avM9RmLiGakg7vz974ms99nEV0tmTQ=="
+        },
+        "js-utils": {
+          "version": "github:jitsi/js-utils#df68966e3c65b5c57fcd2670da1326a2c77518d1",
+          "from": "github:jitsi/js-utils#df68966e3c65b5c57fcd2670da1326a2c77518d1",
+          "requires": {
+            "bowser": "2.7.0",
+            "js-md5": "0.7.3",
+            "postis": "2.2.0"
+          }
+        }
       }
     },
     "libflacjs": {

package.json

     "jquery-contextmenu": "2.4.5",
     "jquery-i18next": "1.2.1",
     "js-md5": "0.6.1",
-    "js-utils": "github:jitsi/js-utils#df68966e3c65b5c57fcd2670da1326a2c77518d1",
+    "js-utils": "github:jitsi/js-utils#efb02828785b2b532097d96f4b32a101847ba58b",
     "jsrsasign": "8.0.12",
     "jwt-decode": "2.2.0",
     "lib-jitsi-meet": "github:jitsi/lib-jitsi-meet#dffe94f270f692c7421412bbbc597279e4a2d805",

react/features/base/app/components/BaseApp.js

 // @flow
 
+import { jitsiLocalStorage } from 'js-utils';
 import _ from 'lodash';
 import React, { Component, Fragment } from 'react';
 import { I18nextProvider } from 'react-i18next';
 } from '../../redux';
 import { SoundCollection } from '../../sounds';
 import { PersistenceRegistry } from '../../storage';
-
 import { appWillMount, appWillUnmount } from '../actions';
 import logger from '../logger';
 
      * @returns {Promise}
      */
     _initStorage(): Promise<*> {
-        const { _initializing } = window.localStorage;
+        const _initializing = jitsiLocalStorage.getItem('_initializing');
 
         return _initializing || Promise.resolve();
     }

react/features/base/config/actions.js

 // @flow
 
+import { jitsiLocalStorage } from 'js-utils';
 import type { Dispatch } from 'redux';
 
 import { addKnownDomains } from '../known-domains';
         let b = false;
 
         try {
-            if (typeof window.config === 'undefined'
-                    || window.config !== config) {
-                window.localStorage.setItem(
-                    `${_CONFIG_STORE_PREFIX}/${baseURL}`,
-                    JSON.stringify(config));
+            if (typeof window.config === 'undefined' || window.config !== config) {
+                jitsiLocalStorage.setItem(`${_CONFIG_STORE_PREFIX}/${baseURL}`, JSON.stringify(config));
                 b = true;
             }
         } catch (e) {

react/features/base/config/functions.any.js

 // @flow
 
+import { jitsiLocalStorage } from 'js-utils';
 import _ from 'lodash';
 
 import CONFIG_WHITELIST from './configWhitelist';
  * otherwise, {@code undefined}.
  */
 export function restoreConfig(baseURL: string): ?Object {
-    let storage;
     const key = `${_CONFIG_STORE_PREFIX}/${baseURL}`;
+    const config = jitsiLocalStorage.getItem(key);
 
-    try {
-        // XXX Even reading the property localStorage of window may throw an
-        // error (which is user agent-specific behavior).
-        storage = window.localStorage;
-
-        const config = storage.getItem(key);
-
-        if (config) {
+    if (config) {
+        try {
             return JSON.parse(config) || undefined;
+        } catch (e) {
+            // Somehow incorrect data ended up in the storage. Clean it up.
+            jitsiLocalStorage.removeItem(key);
         }
-    } catch (e) {
-        // Somehow incorrect data ended up in the storage. Clean it up.
-        storage && storage.removeItem(key);
     }
 
     return undefined;

react/features/base/config/middleware.js

 // @flow
 
+import { jitsiLocalStorage } from 'js-utils';
+
 import { APP_WILL_MOUNT } from '../app';
 import { addKnownDomains } from '../known-domains';
 import { MiddlewareRegistry } from '../redux';
     // consequently, the feature known-domains, it's possible for the feature
     // base/config to know of domains which the feature known-domains is yet to
     // discover.
-    const { localStorage } = window;
 
-    if (localStorage) {
-        const prefix = `${_CONFIG_STORE_PREFIX}/`;
-        const knownDomains = [];
+    const prefix = `${_CONFIG_STORE_PREFIX}/`;
+    const knownDomains = [];
 
-        for (let i = 0; /* localStorage.key(i) */; ++i) {
-            const key = localStorage.key(i);
+    for (let i = 0; /* localStorage.key(i) */; ++i) {
+        const key = jitsiLocalStorage.key(i);
 
-            if (key) {
-                let baseURL;
+        if (key) {
+            let baseURL;
 
-                if (key.startsWith(prefix)
-                        && (baseURL = key.substring(prefix.length))) {
-                    const uri = parseURIString(baseURL);
-                    let host;
+            if (key.startsWith(prefix)
+                    && (baseURL = key.substring(prefix.length))) {
+                const uri = parseURIString(baseURL);
+                let host;
 
-                    uri && (host = uri.host) && knownDomains.push(host);
-                }
-            } else {
-                break;
+                uri && (host = uri.host) && knownDomains.push(host);
             }
+        } else {
+            break;
         }
-        knownDomains.length && store.dispatch(addKnownDomains(knownDomains));
     }
+    knownDomains.length && store.dispatch(addKnownDomains(knownDomains));
 
     return result;
 }

react/features/base/settings/reducer.js

 // @flow
 
+import { jitsiLocalStorage } from 'js-utils';
 import { randomHexString } from 'js-utils/random';
 import _ from 'lodash';
 
  * @returns {Object}
  */
 function _getLegacyProfile() {
-    let persistedProfile
-        = window.localStorage.getItem('features/base/profile');
+    let persistedProfile = jitsiLocalStorage.getItem('features/base/profile');
 
     if (persistedProfile) {
         try {
     // FIXME: jibri uses old settings.js local storage values to set its display
     // name and email. Provide another way for jibri to set these values, update
     // jibri, and remove the old settings.js values.
-    const savedDisplayName = window.localStorage.getItem('displayname');
-    const savedEmail = window.localStorage.getItem('email');
-    let avatarID = _.escape(window.localStorage.getItem('avatarId'));
+    const savedDisplayName = jitsiLocalStorage.getItem('displayname');
+    const savedEmail = jitsiLocalStorage.getItem('email');
+    let avatarID = _.escape(jitsiLocalStorage.getItem('avatarId'));
 
     // The helper _.escape will convert null to an empty strings. The empty
     // string will be saved in settings. On app re-load, because an empty string
 
     if (!browser.isReactNative()) {
         // Browser only
-        const localFlipX
-            = JSON.parse(window.localStorage.getItem('localFlipX') || 'true');
-        const cameraDeviceId
-            = window.localStorage.getItem('cameraDeviceId') || '';
-        const micDeviceId = window.localStorage.getItem('micDeviceId') || '';
+        const localFlipX = JSON.parse(jitsiLocalStorage.getItem('localFlipX') || 'true');
+        const cameraDeviceId = jitsiLocalStorage.getItem('cameraDeviceId') || '';
+        const micDeviceId = jitsiLocalStorage.getItem('micDeviceId') || '';
 
         // Currently audio output device change is supported only in Chrome and
         // default output always has 'default' device ID
-        const audioOutputDeviceId
-            = window.localStorage.getItem('audioOutputDeviceId') || 'default';
+        const audioOutputDeviceId = jitsiLocalStorage.getItem('audioOutputDeviceId') || 'default';
 
         settings = assignIfDefined({
             audioOutputDeviceId,

react/features/base/storage/PersistenceRegistry.js

 // @flow
 
 import md5 from 'js-md5';
+import { jitsiLocalStorage } from 'js-utils';
 
 import logger from './logger';
 
 
         // legacy
         if (Object.keys(filteredPersistedState).length === 0) {
-            const { localStorage } = window;
-            let persistedState = localStorage.getItem(PERSISTED_STATE_NAME);
+            let persistedState = jitsiLocalStorage.getItem(PERSISTED_STATE_NAME);
 
             if (persistedState) {
                 try {
                 // Store into the new format and delete the old format so that
                 // it's not used again.
                 this.persistState(filteredPersistedState);
-                localStorage.removeItem(PERSISTED_STATE_NAME);
+                jitsiLocalStorage.removeItem(PERSISTED_STATE_NAME);
             }
         }
 
         if (checksum !== this._checksum) {
             for (const subtreeName of Object.keys(filteredState)) {
                 try {
-                    window.localStorage.setItem(
-                        subtreeName,
-                        JSON.stringify(filteredState[subtreeName]));
+                    jitsiLocalStorage.setItem(subtreeName, JSON.stringify(filteredState[subtreeName]));
                 } catch (error) {
-                    logger.error(
-                        'Error persisting redux subtree',
-                        subtreeName,
-                        error);
+                    logger.error('Error persisting redux subtree', subtreeName, error);
                 }
             }
-            logger.info(
-                `redux state persisted. ${this._checksum} -> ${checksum}`);
+            logger.info(`redux state persisted. ${this._checksum} -> ${checksum}`);
             this._checksum = checksum;
         }
     }
      * @returns {Object}
      */
     _getPersistedSubtree(subtreeName, subtreeConfig, subtreeDefaults) {
-        let persistedSubtree = window.localStorage.getItem(subtreeName);
+        let persistedSubtree = jitsiLocalStorage.getItem(subtreeName);
 
         if (persistedSubtree) {
             try {

react/features/chrome-extension-banner/components/ChromeExtensionBanner.web.js

 // @flow
+
+import { jitsiLocalStorage } from 'js-utils';
 import React, { PureComponent } from 'react';
-import { connect } from '../../base/redux';
+
+import {
+    createChromeExtensionBannerEvent,
+    sendAnalytics
+} from '../../analytics';
+import { getCurrentConference } from '../../base/conference/functions';
 import { Icon, IconClose } from '../../base/icons';
 import { translate } from '../../base/i18n';
-import { getCurrentConference } from '../../base/conference/functions';
 import { browser } from '../../base/lib-jitsi-meet';
+import { connect } from '../../base/redux';
 import {
     checkChromeExtensionsInstalled,
     isMobileBrowser
 } from '../../base/environment/utils';
+
 import logger from '../logger';
-import {
-    createChromeExtensionBannerEvent,
-    sendAnalytics
-} from '../../analytics';
+
 
 declare var interfaceConfig: Object;
 
             return true;
         }
 
-        const dontShowAgain = localStorage.getItem(DONT_SHOW_AGAIN_CHECKED) === 'true';
+        const dontShowAgain = jitsiLocalStorage.getItem(DONT_SHOW_AGAIN_CHECKED) === 'true';
 
         return !this.props.bannerCfg.url
             || dontShowAgain
     render() {
         if (this._shouldNotRender()) {
             if (this.state.dontShowAgainChecked) {
-                localStorage.setItem(DONT_SHOW_AGAIN_CHECKED, 'true');
+                jitsiLocalStorage.setItem(DONT_SHOW_AGAIN_CHECKED, 'true');
             }
 
             return null;

react/features/local-recording/session/SessionManager.js

 /* @flow */
 
-import jitsiLocalStorage from '../../../../modules/util/JitsiLocalStorage';
+import { jitsiLocalStorage } from 'js-utils';
 
 import logger from '../logger';
 

react/features/recent-list/reducer.js

 // @flow
+
+import { jitsiLocalStorage } from 'js-utils';
+
 import { APP_WILL_MOUNT } from '../base/app';
 import { getURLWithoutParamsNormalized } from '../base/connection';
 import { ReducerRegistry } from '../base/redux';
  * @returns {Array<Object>}
  */
 function _getLegacyRecentRoomList(): Array<Object> {
-    try {
-        const str = window.localStorage.getItem(LEGACY_STORAGE_KEY);
+    const str = jitsiLocalStorage.getItem(LEGACY_STORAGE_KEY);
 
-        if (str) {
+    if (str) {
+        try {
             return JSON.parse(str);
+        } catch (error) {
+            logger.warn('Failed to parse legacy recent-room list!');
         }
-    } catch (error) {
-        logger.warn('Failed to parse legacy recent-room list!');
     }
 
+
     return [];
 }