DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/common/Settings.js

 /*
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 /**
  * @unrestricted
  */
-WebInspector.Settings = class {
+Common.Settings = class {
   /**
-   * @param {!WebInspector.SettingsStorage} globalStorage
-   * @param {!WebInspector.SettingsStorage} localStorage
+   * @param {!Common.SettingsStorage} globalStorage
+   * @param {!Common.SettingsStorage} localStorage
    */
   constructor(globalStorage, localStorage) {
     this._settingsStorage = globalStorage;
     this._localStorage = localStorage;
 
-    this._eventSupport = new WebInspector.Object();
-    /** @type {!Map<string, !WebInspector.Setting>} */
+    this._eventSupport = new Common.Object();
+    /** @type {!Map<string, !Common.Setting>} */
     this._registry = new Map();
-    /** @type {!Map<string, !WebInspector.Setting>} */
+    /** @type {!Map<string, !Common.Setting>} */
     this._moduleSettings = new Map();
     self.runtime.extensions('setting').forEach(this._registerModuleSetting.bind(this));
   }
 
   /**
    * @param {!Runtime.Extension} extension
    */
   _registerModuleSetting(extension) {
     var descriptor = extension.descriptor();
     var settingName = descriptor['settingName'];
     var settingType = descriptor['settingType'];
     var defaultValue = descriptor['defaultValue'];
     var isLocal = !!descriptor['local'];
     var setting = settingType === 'regex' ? this.createRegExpSetting(settingName, defaultValue, undefined, isLocal) :
                                             this.createSetting(settingName, defaultValue, isLocal);
     this._moduleSettings.set(settingName, setting);
   }
 
   /**
    * @param {string} settingName
-   * @return {!WebInspector.Setting}
+   * @return {!Common.Setting}
    */
   moduleSetting(settingName) {
     var setting = this._moduleSettings.get(settingName);
     if (!setting)
       throw new Error('No setting registered: ' + settingName);
     return setting;
   }
 
   /**
    * @param {string} settingName
-   * @return {!WebInspector.Setting}
+   * @return {!Common.Setting}
    */
   settingForTest(settingName) {
     var setting = this._registry.get(settingName);
     if (!setting)
       throw new Error('No setting registered: ' + settingName);
     return setting;
   }
 
   /**
    * @param {string} key
    * @param {*} defaultValue
    * @param {boolean=} isLocal
-   * @return {!WebInspector.Setting}
+   * @return {!Common.Setting}
    */
   createSetting(key, defaultValue, isLocal) {
     if (!this._registry.get(key))
       this._registry.set(
-          key, new WebInspector.Setting(
+          key, new Common.Setting(
                    this, key, defaultValue, this._eventSupport, isLocal ? this._localStorage : this._settingsStorage));
-    return /** @type {!WebInspector.Setting} */ (this._registry.get(key));
+    return /** @type {!Common.Setting} */ (this._registry.get(key));
   }
 
   /**
    * @param {string} key
    * @param {*} defaultValue
-   * @return {!WebInspector.Setting}
+   * @return {!Common.Setting}
    */
   createLocalSetting(key, defaultValue) {
     return this.createSetting(key, defaultValue, true);
   }
 
   /**
    * @param {string} key
    * @param {string} defaultValue
    * @param {string=} regexFlags
    * @param {boolean=} isLocal
-   * @return {!WebInspector.RegExpSetting}
+   * @return {!Common.RegExpSetting}
    */
   createRegExpSetting(key, defaultValue, regexFlags, isLocal) {
     if (!this._registry.get(key))
       this._registry.set(
-          key, new WebInspector.RegExpSetting(
+          key, new Common.RegExpSetting(
                    this, key, defaultValue, this._eventSupport, isLocal ? this._localStorage : this._settingsStorage,
                    regexFlags));
-    return /** @type {!WebInspector.RegExpSetting} */ (this._registry.get(key));
+    return /** @type {!Common.RegExpSetting} */ (this._registry.get(key));
   }
 
   clearAll() {
     this._settingsStorage.removeAll();
     this._localStorage.removeAll();
-    var versionSetting = WebInspector.settings.createSetting(WebInspector.VersionController._currentVersionName, 0);
-    versionSetting.set(WebInspector.VersionController.currentVersion);
+    var versionSetting = Common.settings.createSetting(Common.VersionController._currentVersionName, 0);
+    versionSetting.set(Common.VersionController.currentVersion);
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.SettingsStorage = class {
+Common.SettingsStorage = class {
   /**
    * @param {!Object} object
    * @param {function(string, string)=} setCallback
    * @param {function(string)=} removeCallback
    * @param {function(string)=} removeAllCallback
    * @param {string=} storagePrefix
    */
   constructor(object, setCallback, removeCallback, removeAllCallback, storagePrefix) {
     this._object = object;
     this._setCallback = setCallback || function() {};
@@ skipping 38 matching lines @@
     delete this._object[name];
     this._removeCallback(name);
   }
 
   removeAll() {
     this._object = {};
     this._removeAllCallback();
   }
 
   _dumpSizes() {
-    WebInspector.console.log('Ten largest settings: ');
+    Common.console.log('Ten largest settings: ');
 
     var sizes = {__proto__: null};
     for (var key in this._object)
       sizes[key] = this._object[key].length;
     var keys = Object.keys(sizes);
 
     function comparator(key1, key2) {
       return sizes[key2] - sizes[key1];
     }
 
     keys.sort(comparator);
 
     for (var i = 0; i < 10 && i < keys.length; ++i)
-      WebInspector.console.log('Setting: \'' + keys[i] + '\', size: ' + sizes[keys[i]]);
+      Common.console.log('Setting: \'' + keys[i] + '\', size: ' + sizes[keys[i]]);
   }
 };
 
 /**
  * @template V
  * @unrestricted
  */
-WebInspector.Setting = class {
+Common.Setting = class {
   /**
-   * @param {!WebInspector.Settings} settings
+   * @param {!Common.Settings} settings
    * @param {string} name
    * @param {V} defaultValue
-   * @param {!WebInspector.Object} eventSupport
-   * @param {!WebInspector.SettingsStorage} storage
+   * @param {!Common.Object} eventSupport
+   * @param {!Common.SettingsStorage} storage
    */
   constructor(settings, name, defaultValue, eventSupport, storage) {
     this._settings = settings;
     this._name = name;
     this._defaultValue = defaultValue;
     this._eventSupport = eventSupport;
     this._storage = storage;
   }
 
   /**
-   * @param {function(!WebInspector.Event)} listener
+   * @param {function(!Common.Event)} listener
    * @param {!Object=} thisObject
    */
   addChangeListener(listener, thisObject) {
     this._eventSupport.addEventListener(this._name, listener, thisObject);
   }
 
   /**
-   * @param {function(!WebInspector.Event)} listener
+   * @param {function(!Common.Event)} listener
    * @param {!Object=} thisObject
    */
   removeChangeListener(listener, thisObject) {
     this._eventSupport.removeEventListener(this._name, listener, thisObject);
   }
 
   get name() {
     return this._name;
   }
 
@@ skipping 21 matching lines @@
   set(value) {
     this._value = value;
     try {
       var settingString = JSON.stringify(value);
       try {
         this._storage.set(this._name, settingString);
       } catch (e) {
         this._printSettingsSavingError(e.message, this._name, settingString);
       }
     } catch (e) {
-      WebInspector.console.error('Cannot stringify setting with name: ' + this._name + ', error: ' + e.message);
+      Common.console.error('Cannot stringify setting with name: ' + this._name + ', error: ' + e.message);
     }
     this._eventSupport.dispatchEventToListeners(this._name, value);
   }
 
   remove() {
     this._settings._registry.delete(this._name);
     this._settings._moduleSettings.delete(this._name);
     this._storage.remove(this._name);
   }
 
   /**
    * @param {string} message
    * @param {string} name
    * @param {string} value
    */
   _printSettingsSavingError(message, name, value) {
     var errorMessage =
         'Error saving setting with name: ' + this._name + ', value length: ' + value.length + '. Error: ' + message;
     console.error(errorMessage);
-    WebInspector.console.error(errorMessage);
+    Common.console.error(errorMessage);
     this._storage._dumpSizes();
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.RegExpSetting = class extends WebInspector.Setting {
+Common.RegExpSetting = class extends Common.Setting {
   /**
-   * @param {!WebInspector.Settings} settings
+   * @param {!Common.Settings} settings
    * @param {string} name
    * @param {string} defaultValue
-   * @param {!WebInspector.Object} eventSupport
-   * @param {!WebInspector.SettingsStorage} storage
+   * @param {!Common.Object} eventSupport
+   * @param {!Common.SettingsStorage} storage
    * @param {string=} regexFlags
    */
   constructor(settings, name, defaultValue, eventSupport, storage, regexFlags) {
     super(settings, name, defaultValue ? [{pattern: defaultValue}] : [], eventSupport, storage);
     this._regexFlags = regexFlags;
   }
 
   /**
    * @override
    * @return {string}
@@ skipping 45 matching lines @@
         this._regex = new RegExp(pattern, this._regexFlags || '');
     } catch (e) {
     }
     return this._regex;
   }
 };
 
 /**
  * @unrestricted
  */
-WebInspector.VersionController = class {
+Common.VersionController = class {
   updateVersion() {
     var localStorageVersion =
-        window.localStorage ? window.localStorage[WebInspector.VersionController._currentVersionName] : 0;
-    var versionSetting = WebInspector.settings.createSetting(WebInspector.VersionController._currentVersionName, 0);
-    var currentVersion = WebInspector.VersionController.currentVersion;
+        window.localStorage ? window.localStorage[Common.VersionController._currentVersionName] : 0;
+    var versionSetting = Common.settings.createSetting(Common.VersionController._currentVersionName, 0);
+    var currentVersion = Common.VersionController.currentVersion;
     var oldVersion = versionSetting.get() || parseInt(localStorageVersion || '0', 10);
     if (oldVersion === 0) {
       // First run, no need to do anything.
       versionSetting.set(currentVersion);
       return;
     }
     var methodsToRun = this._methodsToRunToUpdateVersion(oldVersion, currentVersion);
     for (var i = 0; i < methodsToRun.length; ++i)
       this[methodsToRun[i]].call(this);
     versionSetting.set(currentVersion);
   }
 
   /**
    * @param {number} oldVersion
    * @param {number} currentVersion
    */
   _methodsToRunToUpdateVersion(oldVersion, currentVersion) {
     var result = [];
     for (var i = oldVersion; i < currentVersion; ++i)
       result.push('_updateVersionFrom' + i + 'To' + (i + 1));
     return result;
   }
 
   _updateVersionFrom0To1() {
-    this._clearBreakpointsWhenTooMany(WebInspector.settings.createLocalSetting('breakpoints', []), 500000);
+    this._clearBreakpointsWhenTooMany(Common.settings.createLocalSetting('breakpoints', []), 500000);
   }
 
   _updateVersionFrom1To2() {
-    WebInspector.settings.createSetting('previouslyViewedFiles', []).set([]);
+    Common.settings.createSetting('previouslyViewedFiles', []).set([]);
   }
 
   _updateVersionFrom2To3() {
-    WebInspector.settings.createSetting('fileSystemMapping', {}).set({});
-    WebInspector.settings.createSetting('fileMappingEntries', []).remove();
+    Common.settings.createSetting('fileSystemMapping', {}).set({});
+    Common.settings.createSetting('fileMappingEntries', []).remove();
   }
 
   _updateVersionFrom3To4() {
-    var advancedMode = WebInspector.settings.createSetting('showHeaSnapshotObjectsHiddenProperties', false);
-    WebInspector.moduleSetting('showAdvancedHeapSnapshotProperties').set(advancedMode.get());
+    var advancedMode = Common.settings.createSetting('showHeaSnapshotObjectsHiddenProperties', false);
+    Common.moduleSetting('showAdvancedHeapSnapshotProperties').set(advancedMode.get());
     advancedMode.remove();
   }
 
   _updateVersionFrom4To5() {
     var settingNames = {
       'FileSystemViewSidebarWidth': 'fileSystemViewSplitViewState',
       'elementsSidebarWidth': 'elementsPanelSplitViewState',
       'StylesPaneSplitRatio': 'stylesPaneSplitViewState',
       'heapSnapshotRetainersViewSize': 'heapSnapshotSplitViewState',
       'InspectorView.splitView': 'InspectorView.splitViewState',
@@ skipping 11 matching lines @@
       'layersSidebarWidth': 'layersPanelSplitViewState',
       'profilesSidebarWidth': 'profilesPanelSplitViewState',
       'resourcesSidebarWidth': 'resourcesPanelSplitViewState'
     };
     var empty = {};
     for (var oldName in settingNames) {
       var newName = settingNames[oldName];
       var oldNameH = oldName + 'H';
 
       var newValue = null;
-      var oldSetting = WebInspector.settings.createSetting(oldName, empty);
+      var oldSetting = Common.settings.createSetting(oldName, empty);
       if (oldSetting.get() !== empty) {
         newValue = newValue || {};
         newValue.vertical = {};
         newValue.vertical.size = oldSetting.get();
         oldSetting.remove();
       }
-      var oldSettingH = WebInspector.settings.createSetting(oldNameH, empty);
+      var oldSettingH = Common.settings.createSetting(oldNameH, empty);
       if (oldSettingH.get() !== empty) {
         newValue = newValue || {};
         newValue.horizontal = {};
         newValue.horizontal.size = oldSettingH.get();
         oldSettingH.remove();
       }
       if (newValue)
-        WebInspector.settings.createSetting(newName, {}).set(newValue);
+        Common.settings.createSetting(newName, {}).set(newValue);
     }
   }
 
   _updateVersionFrom5To6() {
     var settingNames = {
       'debuggerSidebarHidden': 'sourcesPanelSplitViewState',
       'navigatorHidden': 'sourcesPanelNavigatorSplitViewState',
       'WebInspector.Drawer.showOnLoad': 'Inspector.drawerSplitViewState'
     };
 
     for (var oldName in settingNames) {
-      var oldSetting = WebInspector.settings.createSetting(oldName, null);
+      var oldSetting = Common.settings.createSetting(oldName, null);
       if (oldSetting.get() === null) {
         oldSetting.remove();
         continue;
       }
 
       var newName = settingNames[oldName];
       var invert = oldName === 'WebInspector.Drawer.showOnLoad';
       var hidden = oldSetting.get() !== invert;
       oldSetting.remove();
       var showMode = hidden ? 'OnlyMain' : 'Both';
 
-      var newSetting = WebInspector.settings.createSetting(newName, {});
+      var newSetting = Common.settings.createSetting(newName, {});
       var newValue = newSetting.get() || {};
       newValue.vertical = newValue.vertical || {};
       newValue.vertical.showMode = showMode;
       newValue.horizontal = newValue.horizontal || {};
       newValue.horizontal.showMode = showMode;
       newSetting.set(newValue);
     }
   }
 
   _updateVersionFrom6To7() {
     var settingNames = {
       'sourcesPanelNavigatorSplitViewState': 'sourcesPanelNavigatorSplitViewState',
       'elementsPanelSplitViewState': 'elementsPanelSplitViewState',
       'stylesPaneSplitViewState': 'stylesPaneSplitViewState',
       'sourcesPanelDebuggerSidebarSplitViewState': 'sourcesPanelDebuggerSidebarSplitViewState'
     };
 
     var empty = {};
     for (var name in settingNames) {
-      var setting = WebInspector.settings.createSetting(name, empty);
+      var setting = Common.settings.createSetting(name, empty);
       var value = setting.get();
       if (value === empty)
         continue;
       // Zero out saved percentage sizes, and they will be restored to defaults.
       if (value.vertical && value.vertical.size && value.vertical.size < 1)
         value.vertical.size = 0;
       if (value.horizontal && value.horizontal.size && value.horizontal.size < 1)
         value.horizontal.size = 0;
       setting.set(value);
     }
   }
 
   _updateVersionFrom7To8() {
   }
 
   _updateVersionFrom8To9() {
     var settingNames = ['skipStackFramesPattern', 'workspaceFolderExcludePattern'];
 
     for (var i = 0; i < settingNames.length; ++i) {
-      var setting = WebInspector.settings.createSetting(settingNames[i], '');
+      var setting = Common.settings.createSetting(settingNames[i], '');
       var value = setting.get();
       if (!value)
         return;
       if (typeof value === 'string')
         value = [value];
       for (var j = 0; j < value.length; ++j) {
         if (typeof value[j] === 'string')
           value[j] = {pattern: value[j]};
       }
       setting.set(value);
     }
   }
 
   _updateVersionFrom9To10() {
     // This one is localStorage specific, which is fine.
     if (!window.localStorage)
       return;
     for (var key in window.localStorage) {
       if (key.startsWith('revision-history'))
         window.localStorage.removeItem(key);
     }
   }
 
   _updateVersionFrom10To11() {
     var oldSettingName = 'customDevicePresets';
     var newSettingName = 'customEmulatedDeviceList';
-    var oldSetting = WebInspector.settings.createSetting(oldSettingName, undefined);
+    var oldSetting = Common.settings.createSetting(oldSettingName, undefined);
     var list = oldSetting.get();
     if (!Array.isArray(list))
       return;
     var newList = [];
     for (var i = 0; i < list.length; ++i) {
       var value = list[i];
       var device = {};
       device['title'] = value['title'];
       device['type'] = 'unknown';
       device['user-agent'] = value['userAgent'];
       device['capabilities'] = [];
       if (value['touch'])
         device['capabilities'].push('touch');
       if (value['mobile'])
         device['capabilities'].push('mobile');
       device['screen'] = {};
       device['screen']['vertical'] = {width: value['width'], height: value['height']};
       device['screen']['horizontal'] = {width: value['height'], height: value['width']};
       device['screen']['device-pixel-ratio'] = value['deviceScaleFactor'];
       device['modes'] = [];
       device['show-by-default'] = true;
       device['show'] = 'Default';
       newList.push(device);
     }
     if (newList.length)
-      WebInspector.settings.createSetting(newSettingName, []).set(newList);
+      Common.settings.createSetting(newSettingName, []).set(newList);
     oldSetting.remove();
   }
 
   _updateVersionFrom11To12() {
     this._migrateSettingsFromLocalStorage();
   }
 
   _updateVersionFrom12To13() {
     this._migrateSettingsFromLocalStorage();
-    WebInspector.settings.createSetting('timelineOverviewMode', '').remove();
+    Common.settings.createSetting('timelineOverviewMode', '').remove();
   }
 
   _updateVersionFrom13To14() {
     var defaultValue = {'throughput': -1, 'latency': 0};
-    WebInspector.settings.createSetting('networkConditions', defaultValue).set(defaultValue);
+    Common.settings.createSetting('networkConditions', defaultValue).set(defaultValue);
   }
 
   _updateVersionFrom14To15() {
-    var setting = WebInspector.settings.createLocalSetting('workspaceExcludedFolders', {});
+    var setting = Common.settings.createLocalSetting('workspaceExcludedFolders', {});
     var oldValue = setting.get();
     var newValue = {};
     for (var fileSystemPath in oldValue) {
       newValue[fileSystemPath] = [];
       for (var entry of oldValue[fileSystemPath])
         newValue[fileSystemPath].push(entry.path);
     }
     setting.set(newValue);
   }
 
   _updateVersionFrom15To16() {
-    var setting = WebInspector.settings.createSetting('InspectorView.panelOrder', {});
+    var setting = Common.settings.createSetting('InspectorView.panelOrder', {});
     var tabOrders = setting.get();
     for (var key of Object.keys(tabOrders))
       tabOrders[key] = (tabOrders[key] + 1) * 10;
     setting.set(tabOrders);
   }
 
   _updateVersionFrom16To17() {
-    var setting = WebInspector.settings.createSetting('networkConditionsCustomProfiles', []);
+    var setting = Common.settings.createSetting('networkConditionsCustomProfiles', []);
     var oldValue = setting.get();
     var newValue = [];
     if (Array.isArray(oldValue)) {
       for (var preset of oldValue) {
         if (typeof preset.title === 'string' && typeof preset.value === 'object' &&
             typeof preset.value.throughput === 'number' && typeof preset.value.latency === 'number')
           newValue.push({
             title: preset.title,
             value:
                 {download: preset.value.throughput, upload: preset.value.throughput, latency: preset.value.latency}
           });
       }
     }
     setting.set(newValue);
   }
 
   _updateVersionFrom17To18() {
-    var setting = WebInspector.settings.createLocalSetting('workspaceExcludedFolders', {});
+    var setting = Common.settings.createLocalSetting('workspaceExcludedFolders', {});
     var oldValue = setting.get();
     var newValue = {};
     for (var oldKey in oldValue) {
       var newKey = oldKey.replace(/\\/g, '/');
       if (!newKey.startsWith('file://')) {
         if (newKey.startsWith('/'))
           newKey = 'file://' + newKey;
         else
           newKey = 'file:///' + newKey;
       }
       newValue[newKey] = oldValue[oldKey];
     }
     setting.set(newValue);
   }
 
   _updateVersionFrom18To19() {
     var defaultColumns = {status: true, type: true, initiator: true, size: true, time: true};
-    var visibleColumnSettings = WebInspector.settings.createSetting('networkLogColumnsVisibility', defaultColumns);
+    var visibleColumnSettings = Common.settings.createSetting('networkLogColumnsVisibility', defaultColumns);
     var visibleColumns = visibleColumnSettings.get();
     visibleColumns.name = true;
     visibleColumns.timeline = true;
 
     var configs = {};
     for (var columnId in visibleColumns) {
       if (!visibleColumns.hasOwnProperty(columnId))
         continue;
       configs[columnId.toLowerCase()] = {visible: visibleColumns[columnId]};
     }
-    var newSetting = WebInspector.settings.createSetting('networkLogColumns', {});
+    var newSetting = Common.settings.createSetting('networkLogColumns', {});
     newSetting.set(configs);
     visibleColumnSettings.remove();
   }
 
   _updateVersionFrom19To20() {
-    var oldSetting = WebInspector.settings.createSetting('InspectorView.panelOrder', {});
-    var newSetting = WebInspector.settings.createSetting('panel-tabOrder', {});
+    var oldSetting = Common.settings.createSetting('InspectorView.panelOrder', {});
+    var newSetting = Common.settings.createSetting('panel-tabOrder', {});
     newSetting.set(oldSetting.get());
     oldSetting.remove();
   }
 
   _migrateSettingsFromLocalStorage() {
     // This step migrates all the settings except for the ones below into the browser profile.
     var localSettings = new Set([
       'advancedSearchConfig', 'breakpoints', 'consoleHistory', 'domBreakpoints', 'eventListenerBreakpoints',
       'fileSystemMapping', 'lastSelectedSourcesSidebarPaneTab', 'previouslyViewedFiles', 'savedURLs',
       'watchExpressions', 'workspaceExcludedFolders', 'xhrBreakpoints'
     ]);
     if (!window.localStorage)
       return;
 
     for (var key in window.localStorage) {
       if (localSettings.has(key))
         continue;
       var value = window.localStorage[key];
       window.localStorage.removeItem(key);
-      WebInspector.settings._settingsStorage[key] = value;
+      Common.settings._settingsStorage[key] = value;
     }
   }
 
   /**
-   * @param {!WebInspector.Setting} breakpointsSetting
+   * @param {!Common.Setting} breakpointsSetting
    * @param {number} maxBreakpointsCount
    */
   _clearBreakpointsWhenTooMany(breakpointsSetting, maxBreakpointsCount) {
     // If there are too many breakpoints in a storage, it is likely due to a recent bug that caused
     // periodical breakpoints duplication leading to inspector slowness.
     if (breakpointsSetting.get().length > maxBreakpointsCount)
       breakpointsSetting.set([]);
   }
 };
 
-WebInspector.VersionController._currentVersionName = 'inspectorVersion';
-WebInspector.VersionController.currentVersion = 20;
+Common.VersionController._currentVersionName = 'inspectorVersion';
+Common.VersionController.currentVersion = 20;
 
 /**
- * @type {!WebInspector.Settings}
+ * @type {!Common.Settings}
  */
-WebInspector.settings;
+Common.settings;
 
 /**
  * @param {string} settingName
- * @return {!WebInspector.Setting}
+ * @return {!Common.Setting}
  */
-WebInspector.moduleSetting = function(settingName) {
-  return WebInspector.settings.moduleSetting(settingName);
+Common.moduleSetting = function(settingName) {
+  return Common.settings.moduleSetting(settingName);
 };
 
 /**
  * @param {string} settingName
- * @return {!WebInspector.Setting}
+ * @return {!Common.Setting}
  */
-WebInspector.settingForTest = function(settingName) {
-  return WebInspector.settings.settingForTest(settingName);
+Common.settingForTest = function(settingName) {
+  return Common.settings.settingForTest(settingName);
 };