DevTools: rename WebInspector into modules.

third_party/WebKit/Source/devtools/front_end/emulation/DeviceModeToolbar.js

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 /**
  * @unrestricted
  */
-WebInspector.DeviceModeToolbar = class {
+Emulation.DeviceModeToolbar = class {
   /**
-   * @param {!WebInspector.DeviceModeModel} model
-   * @param {!WebInspector.Setting} showMediaInspectorSetting
-   * @param {!WebInspector.Setting} showRulersSetting
+   * @param {!Emulation.DeviceModeModel} model
+   * @param {!Common.Setting} showMediaInspectorSetting
+   * @param {!Common.Setting} showRulersSetting
    */
   constructor(model, showMediaInspectorSetting, showRulersSetting) {
     this._model = model;
     this._showMediaInspectorSetting = showMediaInspectorSetting;
     this._showRulersSetting = showRulersSetting;
 
     this._deviceOutlineSetting = this._model.deviceOutlineSetting();
-    this._showDeviceScaleFactorSetting = WebInspector.settings.createSetting('emulation.showDeviceScaleFactor', false);
+    this._showDeviceScaleFactorSetting = Common.settings.createSetting('emulation.showDeviceScaleFactor', false);
     this._showDeviceScaleFactorSetting.addChangeListener(this._updateDeviceScaleFactorVisibility, this);
 
-    this._showUserAgentTypeSetting = WebInspector.settings.createSetting('emulation.showUserAgentType', false);
+    this._showUserAgentTypeSetting = Common.settings.createSetting('emulation.showUserAgentType', false);
     this._showUserAgentTypeSetting.addChangeListener(this._updateUserAgentTypeVisibility, this);
 
-    this._showNetworkConditionsSetting = WebInspector.settings.createSetting('emulation.showNetworkConditions', false);
+    this._showNetworkConditionsSetting = Common.settings.createSetting('emulation.showNetworkConditions', false);
     this._showNetworkConditionsSetting.addChangeListener(this._updateNetworkConditionsVisibility, this);
 
-    /** @type {!Map<!WebInspector.EmulatedDevice, !WebInspector.EmulatedDevice.Mode>} */
+    /** @type {!Map<!Emulation.EmulatedDevice, !Emulation.EmulatedDevice.Mode>} */
     this._lastMode = new Map();
 
-    /** @type {!Map<!WebInspector.EmulatedDevice, number>} */
+    /** @type {!Map<!Emulation.EmulatedDevice, number>} */
     this._lastScale = new Map();
 
     this._element = createElementWithClass('div', 'device-mode-toolbar');
 
     var leftContainer = this._element.createChild('div', 'device-mode-toolbar-spacer');
     leftContainer.createChild('div', 'device-mode-toolbar-spacer');
-    var leftToolbar = new WebInspector.Toolbar('', leftContainer);
+    var leftToolbar = new UI.Toolbar('', leftContainer);
     leftToolbar.makeWrappable();
     this._fillLeftToolbar(leftToolbar);
 
-    var mainToolbar = new WebInspector.Toolbar('', this._element);
+    var mainToolbar = new UI.Toolbar('', this._element);
     mainToolbar.makeWrappable();
     this._fillMainToolbar(mainToolbar);
 
     var rightContainer = this._element.createChild('div', 'device-mode-toolbar-spacer');
-    var rightToolbar = new WebInspector.Toolbar('device-mode-toolbar-fixed-size', rightContainer);
+    var rightToolbar = new UI.Toolbar('device-mode-toolbar-fixed-size', rightContainer);
     rightToolbar.makeWrappable();
     this._fillRightToolbar(rightToolbar);
-    var modeToolbar = new WebInspector.Toolbar('device-mode-toolbar-fixed-size', rightContainer);
+    var modeToolbar = new UI.Toolbar('device-mode-toolbar-fixed-size', rightContainer);
     modeToolbar.makeWrappable();
     this._fillModeToolbar(modeToolbar);
     rightContainer.createChild('div', 'device-mode-toolbar-spacer');
-    var optionsToolbar = new WebInspector.Toolbar('', rightContainer);
+    var optionsToolbar = new UI.Toolbar('', rightContainer);
     optionsToolbar.makeWrappable(true);
     this._fillOptionsToolbar(optionsToolbar);
 
-    this._emulatedDevicesList = WebInspector.EmulatedDevicesList.instance();
+    this._emulatedDevicesList = Emulation.EmulatedDevicesList.instance();
     this._emulatedDevicesList.addEventListener(
-        WebInspector.EmulatedDevicesList.Events.CustomDevicesUpdated, this._deviceListChanged, this);
+        Emulation.EmulatedDevicesList.Events.CustomDevicesUpdated, this._deviceListChanged, this);
     this._emulatedDevicesList.addEventListener(
-        WebInspector.EmulatedDevicesList.Events.StandardDevicesUpdated, this._deviceListChanged, this);
+        Emulation.EmulatedDevicesList.Events.StandardDevicesUpdated, this._deviceListChanged, this);
 
     this._persistenceSetting =
-        WebInspector.settings.createSetting('emulation.deviceModeValue', {device: '', orientation: '', mode: ''});
+        Common.settings.createSetting('emulation.deviceModeValue', {device: '', orientation: '', mode: ''});
   }
 
   /**
-   * @param {!WebInspector.Toolbar} toolbar
+   * @param {!UI.Toolbar} toolbar
    */
   _fillLeftToolbar(toolbar) {
     toolbar.appendToolbarItem(
         this._wrapToolbarItem(createElementWithClass('div', 'device-mode-empty-toolbar-element')));
-    this._deviceSelectItem = new WebInspector.ToolbarMenuButton(this._appendDeviceMenuItems.bind(this));
+    this._deviceSelectItem = new UI.ToolbarMenuButton(this._appendDeviceMenuItems.bind(this));
     this._deviceSelectItem.setGlyph('');
     this._deviceSelectItem.turnIntoSelect(95);
     toolbar.appendToolbarItem(this._deviceSelectItem);
   }
 
   /**
-   * @param {!WebInspector.Toolbar} toolbar
+   * @param {!UI.Toolbar} toolbar
    */
   _fillMainToolbar(toolbar) {
     var widthInput = createElementWithClass('input', 'device-mode-size-input');
     widthInput.maxLength = 4;
     widthInput.type = 'text';
-    widthInput.title = WebInspector.UIString('Width');
-    this._updateWidthInput = WebInspector.bindInput(
-        widthInput, this._applyWidth.bind(this), WebInspector.DeviceModeModel.deviceSizeValidator, true);
+    widthInput.title = Common.UIString('Width');
+    this._updateWidthInput = UI.bindInput(
+        widthInput, this._applyWidth.bind(this), Emulation.DeviceModeModel.deviceSizeValidator, true);
     this._widthInput = widthInput;
     this._widthItem = this._wrapToolbarItem(widthInput);
     toolbar.appendToolbarItem(this._widthItem);
 
     var xElement = createElementWithClass('div', 'device-mode-x');
     xElement.textContent = '\u00D7';
     this._xItem = this._wrapToolbarItem(xElement);
     toolbar.appendToolbarItem(this._xItem);
 
     var heightInput = createElementWithClass('input', 'device-mode-size-input');
     heightInput.maxLength = 4;
     heightInput.type = 'text';
-    heightInput.title = WebInspector.UIString('Height (leave empty for full)');
-    this._updateHeightInput = WebInspector.bindInput(heightInput, this._applyHeight.bind(this), validateHeight, true);
+    heightInput.title = Common.UIString('Height (leave empty for full)');
+    this._updateHeightInput = UI.bindInput(heightInput, this._applyHeight.bind(this), validateHeight, true);
     this._heightInput = heightInput;
     this._heightItem = this._wrapToolbarItem(heightInput);
     toolbar.appendToolbarItem(this._heightItem);
 
     /**
      * @param {string} value
      * @return {boolean}
      */
     function validateHeight(value) {
-      return !value || WebInspector.DeviceModeModel.deviceSizeValidator(value);
+      return !value || Emulation.DeviceModeModel.deviceSizeValidator(value);
     }
   }
 
   /**
    * @param {string} value
    */
   _applyWidth(value) {
     var width = value ? Number(value) : 0;
     this._model.setWidthAndScaleToFit(width);
   }
 
   /**
    * @param {string} value
    */
   _applyHeight(value) {
     var height = value ? Number(value) : 0;
     this._model.setHeightAndScaleToFit(height);
   }
 
   /**
-   * @param {!WebInspector.Toolbar} toolbar
+   * @param {!UI.Toolbar} toolbar
    */
   _fillRightToolbar(toolbar) {
     toolbar.appendToolbarItem(
         this._wrapToolbarItem(createElementWithClass('div', 'device-mode-empty-toolbar-element')));
-    this._scaleItem = new WebInspector.ToolbarMenuButton(this._appendScaleMenuItems.bind(this));
-    this._scaleItem.setTitle(WebInspector.UIString('Zoom'));
+    this._scaleItem = new UI.ToolbarMenuButton(this._appendScaleMenuItems.bind(this));
+    this._scaleItem.setTitle(Common.UIString('Zoom'));
     this._scaleItem.setGlyph('');
     this._scaleItem.turnIntoSelect();
     toolbar.appendToolbarItem(this._scaleItem);
 
     toolbar.appendToolbarItem(
         this._wrapToolbarItem(createElementWithClass('div', 'device-mode-empty-toolbar-element')));
-    this._deviceScaleItem = new WebInspector.ToolbarMenuButton(this._appendDeviceScaleMenuItems.bind(this));
+    this._deviceScaleItem = new UI.ToolbarMenuButton(this._appendDeviceScaleMenuItems.bind(this));
     this._deviceScaleItem.setVisible(this._showDeviceScaleFactorSetting.get());
-    this._deviceScaleItem.setTitle(WebInspector.UIString('Device pixel ratio'));
+    this._deviceScaleItem.setTitle(Common.UIString('Device pixel ratio'));
     this._deviceScaleItem.setGlyph('');
     this._deviceScaleItem.turnIntoSelect();
     this._deviceScaleItem.element.style.padding = '0 5px';
     toolbar.appendToolbarItem(this._deviceScaleItem);
 
     toolbar.appendToolbarItem(
         this._wrapToolbarItem(createElementWithClass('div', 'device-mode-empty-toolbar-element')));
-    this._uaItem = new WebInspector.ToolbarMenuButton(this._appendUserAgentMenuItems.bind(this));
+    this._uaItem = new UI.ToolbarMenuButton(this._appendUserAgentMenuItems.bind(this));
     this._uaItem.setVisible(this._showUserAgentTypeSetting.get());
-    this._uaItem.setTitle(WebInspector.UIString('Device type'));
+    this._uaItem.setTitle(Common.UIString('Device type'));
     this._uaItem.setGlyph('');
     this._uaItem.turnIntoSelect();
     this._uaItem.element.style.padding = '0 5px';
     toolbar.appendToolbarItem(this._uaItem);
   }
 
   /**
-   * @param {!WebInspector.Toolbar} toolbar
+   * @param {!UI.Toolbar} toolbar
    */
   _fillModeToolbar(toolbar) {
     toolbar.appendToolbarItem(
         this._wrapToolbarItem(createElementWithClass('div', 'device-mode-empty-toolbar-element')));
-    this._modeButton = new WebInspector.ToolbarButton('', 'largeicon-rotate-screen');
+    this._modeButton = new UI.ToolbarButton('', 'largeicon-rotate-screen');
     this._modeButton.addEventListener('click', this._modeMenuClicked, this);
     toolbar.appendToolbarItem(this._modeButton);
   }
 
   /**
-   * @param {!WebInspector.Toolbar} toolbar
+   * @param {!UI.Toolbar} toolbar
    */
   _fillOptionsToolbar(toolbar) {
-    this._networkConditionsItem = WebInspector.NetworkConditionsSelector.createToolbarMenuButton();
+    this._networkConditionsItem = Components.NetworkConditionsSelector.createToolbarMenuButton();
     this._networkConditionsItem.setVisible(this._showNetworkConditionsSetting.get());
-    this._networkConditionsItem.setTitle(WebInspector.UIString('Network throttling'));
+    this._networkConditionsItem.setTitle(Common.UIString('Network throttling'));
     this._networkConditionsItem.element.style.padding = '0 5px';
     this._networkConditionsItem.element.style.maxWidth = '140px';
     toolbar.appendToolbarItem(this._networkConditionsItem);
 
-    var moreOptionsButton = new WebInspector.ToolbarMenuButton(this._appendOptionsMenuItems.bind(this));
-    moreOptionsButton.setTitle(WebInspector.UIString('More options'));
+    var moreOptionsButton = new UI.ToolbarMenuButton(this._appendOptionsMenuItems.bind(this));
+    moreOptionsButton.setTitle(Common.UIString('More options'));
     toolbar.appendToolbarItem(moreOptionsButton);
 
     toolbar.appendToolbarItem(
         this._wrapToolbarItem(createElementWithClass('div', 'device-mode-empty-toolbar-element')));
   }
 
   /**
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    */
   _appendScaleMenuItems(contextMenu) {
-    if (this._model.type() === WebInspector.DeviceModeModel.Type.Device) {
+    if (this._model.type() === Emulation.DeviceModeModel.Type.Device) {
       contextMenu.appendItem(
-          WebInspector.UIString('Fit to window (%.0f%%)', this._model.fitScale() * 100),
+          Common.UIString('Fit to window (%.0f%%)', this._model.fitScale() * 100),
           this._onScaleMenuChanged.bind(this, this._model.fitScale()), false);
       contextMenu.appendSeparator();
     }
     var boundAppendScaleItem = appendScaleItem.bind(this);
-    boundAppendScaleItem(WebInspector.UIString('50%'), 0.5);
-    boundAppendScaleItem(WebInspector.UIString('75%'), 0.75);
-    boundAppendScaleItem(WebInspector.UIString('100%'), 1);
-    boundAppendScaleItem(WebInspector.UIString('125%'), 1.25);
-    boundAppendScaleItem(WebInspector.UIString('150%'), 1.5);
+    boundAppendScaleItem(Common.UIString('50%'), 0.5);
+    boundAppendScaleItem(Common.UIString('75%'), 0.75);
+    boundAppendScaleItem(Common.UIString('100%'), 1);
+    boundAppendScaleItem(Common.UIString('125%'), 1.25);
+    boundAppendScaleItem(Common.UIString('150%'), 1.5);
 
     /**
      * @param {string} title
      * @param {number} value
-     * @this {!WebInspector.DeviceModeToolbar}
+     * @this {!Emulation.DeviceModeToolbar}
      */
     function appendScaleItem(title, value) {
       contextMenu.appendCheckboxItem(
           title, this._onScaleMenuChanged.bind(this, value), this._model.scaleSetting().get() === value, false);
     }
   }
 
   /**
    * @param {number} value
    */
   _onScaleMenuChanged(value) {
     var device = this._model.device();
     if (device)
       this._lastScale.set(device, value);
     this._model.scaleSetting().set(value);
   }
 
   /**
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    */
   _appendDeviceScaleMenuItems(contextMenu) {
     var deviceScaleFactorSetting = this._model.deviceScaleFactorSetting();
-    var defaultValue = this._model.uaSetting().get() === WebInspector.DeviceModeModel.UA.Mobile ||
-            this._model.uaSetting().get() === WebInspector.DeviceModeModel.UA.MobileNoTouch ?
-        WebInspector.DeviceModeModel.defaultMobileScaleFactor :
+    var defaultValue = this._model.uaSetting().get() === Emulation.DeviceModeModel.UA.Mobile ||
+            this._model.uaSetting().get() === Emulation.DeviceModeModel.UA.MobileNoTouch ?
+        Emulation.DeviceModeModel.defaultMobileScaleFactor :
         window.devicePixelRatio;
-    appendDeviceScaleFactorItem(WebInspector.UIString('Default: %.1f', defaultValue), 0);
+    appendDeviceScaleFactorItem(Common.UIString('Default: %.1f', defaultValue), 0);
     contextMenu.appendSeparator();
-    appendDeviceScaleFactorItem(WebInspector.UIString('1'), 1);
-    appendDeviceScaleFactorItem(WebInspector.UIString('2'), 2);
-    appendDeviceScaleFactorItem(WebInspector.UIString('3'), 3);
+    appendDeviceScaleFactorItem(Common.UIString('1'), 1);
+    appendDeviceScaleFactorItem(Common.UIString('2'), 2);
+    appendDeviceScaleFactorItem(Common.UIString('3'), 3);
 
     /**
      * @param {string} title
      * @param {number} value
      */
     function appendDeviceScaleFactorItem(title, value) {
       contextMenu.appendCheckboxItem(
           title, deviceScaleFactorSetting.set.bind(deviceScaleFactorSetting, value),
           deviceScaleFactorSetting.get() === value);
     }
   }
 
   /**
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    */
   _appendUserAgentMenuItems(contextMenu) {
     var uaSetting = this._model.uaSetting();
-    appendUAItem(WebInspector.DeviceModeModel.UA.Mobile, WebInspector.DeviceModeModel.UA.Mobile);
-    appendUAItem(WebInspector.DeviceModeModel.UA.MobileNoTouch, WebInspector.DeviceModeModel.UA.MobileNoTouch);
-    appendUAItem(WebInspector.DeviceModeModel.UA.Desktop, WebInspector.DeviceModeModel.UA.Desktop);
-    appendUAItem(WebInspector.DeviceModeModel.UA.DesktopTouch, WebInspector.DeviceModeModel.UA.DesktopTouch);
+    appendUAItem(Emulation.DeviceModeModel.UA.Mobile, Emulation.DeviceModeModel.UA.Mobile);
+    appendUAItem(Emulation.DeviceModeModel.UA.MobileNoTouch, Emulation.DeviceModeModel.UA.MobileNoTouch);
+    appendUAItem(Emulation.DeviceModeModel.UA.Desktop, Emulation.DeviceModeModel.UA.Desktop);
+    appendUAItem(Emulation.DeviceModeModel.UA.DesktopTouch, Emulation.DeviceModeModel.UA.DesktopTouch);
 
     /**
      * @param {string} title
-     * @param {!WebInspector.DeviceModeModel.UA} value
+     * @param {!Emulation.DeviceModeModel.UA} value
      */
     function appendUAItem(title, value) {
       contextMenu.appendCheckboxItem(title, uaSetting.set.bind(uaSetting, value), uaSetting.get() === value);
     }
   }
 
   /**
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    */
   _appendOptionsMenuItems(contextMenu) {
     var model = this._model;
     appendToggleItem(
-        this._deviceOutlineSetting, WebInspector.UIString('Hide device frame'),
-        WebInspector.UIString('Show device frame'), model.type() !== WebInspector.DeviceModeModel.Type.Device);
+        this._deviceOutlineSetting, Common.UIString('Hide device frame'),
+        Common.UIString('Show device frame'), model.type() !== Emulation.DeviceModeModel.Type.Device);
     appendToggleItem(
-        this._showMediaInspectorSetting, WebInspector.UIString('Hide media queries'),
-        WebInspector.UIString('Show media queries'));
+        this._showMediaInspectorSetting, Common.UIString('Hide media queries'),
+        Common.UIString('Show media queries'));
     appendToggleItem(
-        this._showRulersSetting, WebInspector.UIString('Hide rulers'), WebInspector.UIString('Show rulers'));
+        this._showRulersSetting, Common.UIString('Hide rulers'), Common.UIString('Show rulers'));
     contextMenu.appendSeparator();
     appendToggleItem(
-        this._showDeviceScaleFactorSetting, WebInspector.UIString('Remove device pixel ratio'),
-        WebInspector.UIString('Add device pixel ratio'));
+        this._showDeviceScaleFactorSetting, Common.UIString('Remove device pixel ratio'),
+        Common.UIString('Add device pixel ratio'));
     appendToggleItem(
-        this._showUserAgentTypeSetting, WebInspector.UIString('Remove device type'),
-        WebInspector.UIString('Add device type'));
+        this._showUserAgentTypeSetting, Common.UIString('Remove device type'),
+        Common.UIString('Add device type'));
     appendToggleItem(
-        this._showNetworkConditionsSetting, WebInspector.UIString('Remove network throttling'),
-        WebInspector.UIString('Add network throttling'));
+        this._showNetworkConditionsSetting, Common.UIString('Remove network throttling'),
+        Common.UIString('Add network throttling'));
     contextMenu.appendSeparator();
     contextMenu.appendItemsAtLocation('deviceModeMenu');
     contextMenu.appendSeparator();
-    contextMenu.appendItem(WebInspector.UIString('Reset to defaults'), this._reset.bind(this));
+    contextMenu.appendItem(Common.UIString('Reset to defaults'), this._reset.bind(this));
 
     /**
-     * @param {!WebInspector.Setting} setting
+     * @param {!Common.Setting} setting
      * @param {string} title1
      * @param {string} title2
      * @param {boolean=} disabled
      */
     function appendToggleItem(setting, title1, title2, disabled) {
       if (typeof disabled === 'undefined')
-        disabled = model.type() === WebInspector.DeviceModeModel.Type.None;
+        disabled = model.type() === Emulation.DeviceModeModel.Type.None;
       contextMenu.appendItem(setting.get() ? title1 : title2, setting.set.bind(setting, !setting.get()), disabled);
     }
   }
 
   _reset() {
     this._deviceOutlineSetting.set(false);
     this._showDeviceScaleFactorSetting.set(false);
     this._showUserAgentTypeSetting.set(false);
     this._showMediaInspectorSetting.set(false);
     this._showRulersSetting.set(false);
     this._showNetworkConditionsSetting.set(false);
     this._model.reset();
   }
 
   /**
    * @param {!Element} element
-   * @return {!WebInspector.ToolbarItem}
+   * @return {!UI.ToolbarItem}
    */
   _wrapToolbarItem(element) {
     var container = createElement('div');
-    var shadowRoot = WebInspector.createShadowRootWithCoreStyles(container, 'emulation/deviceModeToolbar.css');
+    var shadowRoot = UI.createShadowRootWithCoreStyles(container, 'emulation/deviceModeToolbar.css');
     shadowRoot.appendChild(element);
-    return new WebInspector.ToolbarItem(container);
+    return new UI.ToolbarItem(container);
   }
 
   /**
-   * @param {!WebInspector.EmulatedDevice} device
+   * @param {!Emulation.EmulatedDevice} device
    */
   _emulateDevice(device) {
     this._model.emulate(
-        WebInspector.DeviceModeModel.Type.Device, device, this._lastMode.get(device) || device.modes[0],
+        Emulation.DeviceModeModel.Type.Device, device, this._lastMode.get(device) || device.modes[0],
         this._lastScale.get(device));
   }
 
   _switchToResponsive() {
-    this._model.emulate(WebInspector.DeviceModeModel.Type.Responsive, null, null);
+    this._model.emulate(Emulation.DeviceModeModel.Type.Responsive, null, null);
   }
 
   /**
-   * @param {!Array<!WebInspector.EmulatedDevice>} devices
-   * @return {!Array<!WebInspector.EmulatedDevice>}
+   * @param {!Array<!Emulation.EmulatedDevice>} devices
+   * @return {!Array<!Emulation.EmulatedDevice>}
    */
   _filterDevices(devices) {
     devices = devices.filter(function(d) {
       return d.show();
     });
-    devices.sort(WebInspector.EmulatedDevice.deviceComparator);
+    devices.sort(Emulation.EmulatedDevice.deviceComparator);
     return devices;
   }
 
   /**
-   * @return {!Array<!WebInspector.EmulatedDevice>}
+   * @return {!Array<!Emulation.EmulatedDevice>}
    */
   _standardDevices() {
     return this._filterDevices(this._emulatedDevicesList.standard());
   }
 
   /**
-   * @return {!Array<!WebInspector.EmulatedDevice>}
+   * @return {!Array<!Emulation.EmulatedDevice>}
    */
   _customDevices() {
     return this._filterDevices(this._emulatedDevicesList.custom());
   }
 
   /**
-   * @return {!Array<!WebInspector.EmulatedDevice>}
+   * @return {!Array<!Emulation.EmulatedDevice>}
    */
   _allDevices() {
     return this._standardDevices().concat(this._customDevices());
   }
 
   /**
-   * @param {!WebInspector.ContextMenu} contextMenu
+   * @param {!UI.ContextMenu} contextMenu
    */
   _appendDeviceMenuItems(contextMenu) {
     contextMenu.appendCheckboxItem(
-        WebInspector.UIString('Responsive'), this._switchToResponsive.bind(this),
-        this._model.type() === WebInspector.DeviceModeModel.Type.Responsive, false);
+        Common.UIString('Responsive'), this._switchToResponsive.bind(this),
+        this._model.type() === Emulation.DeviceModeModel.Type.Responsive, false);
     appendGroup.call(this, this._standardDevices());
     appendGroup.call(this, this._customDevices());
     contextMenu.appendSeparator();
     contextMenu.appendItem(
-        WebInspector.UIString('Edit\u2026'),
+        Common.UIString('Edit\u2026'),
         this._emulatedDevicesList.revealCustomSetting.bind(this._emulatedDevicesList), false);
 
     /**
-     * @param {!Array<!WebInspector.EmulatedDevice>} devices
-     * @this {WebInspector.DeviceModeToolbar}
+     * @param {!Array<!Emulation.EmulatedDevice>} devices
+     * @this {Emulation.DeviceModeToolbar}
      */
     function appendGroup(devices) {
       if (!devices.length)
         return;
       contextMenu.appendSeparator();
       for (var device of devices)
         contextMenu.appendCheckboxItem(
             device.title, this._emulateDevice.bind(this, device), this._model.device() === device, false);
     }
   }
 
   /**
-   * @this {WebInspector.DeviceModeToolbar}
+   * @this {Emulation.DeviceModeToolbar}
    */
   _deviceListChanged() {
     var device = this._model.device();
     if (!device)
       return;
 
     var devices = this._allDevices();
     if (devices.indexOf(device) === -1) {
       if (devices.length)
         this._emulateDevice(devices[0]);
       else
-        this._model.emulate(WebInspector.DeviceModeModel.Type.Responsive, null, null);
+        this._model.emulate(Emulation.DeviceModeModel.Type.Responsive, null, null);
     }
   }
 
   _updateDeviceScaleFactorVisibility() {
     this._deviceScaleItem.setVisible(this._showDeviceScaleFactorSetting.get());
   }
 
   _updateUserAgentTypeVisibility() {
     this._uaItem.setVisible(this._showUserAgentTypeSetting.get());
   }
 
   _updateNetworkConditionsVisibility() {
     this._networkConditionsItem.setVisible(this._showNetworkConditionsSetting.get());
   }
 
   /**
-   * @param {!WebInspector.Event} event
+   * @param {!Common.Event} event
    */
   _modeMenuClicked(event) {
     var device = this._model.device();
     var model = this._model;
 
     if (device.modes.length === 2 && device.modes[0].orientation !== device.modes[1].orientation) {
       model.emulate(model.type(), model.device(), model.mode() === device.modes[0] ? device.modes[1] : device.modes[0]);
       return;
     }
 
-    var contextMenu = new WebInspector.ContextMenu(
+    var contextMenu = new UI.ContextMenu(
         /** @type {!Event} */ (event.data), false, event.target.element.totalOffsetLeft(),
         event.target.element.totalOffsetTop() + event.target.element.offsetHeight);
-    addOrientation(WebInspector.EmulatedDevice.Vertical, WebInspector.UIString('Portrait'));
-    addOrientation(WebInspector.EmulatedDevice.Horizontal, WebInspector.UIString('Landscape'));
+    addOrientation(Emulation.EmulatedDevice.Vertical, Common.UIString('Portrait'));
+    addOrientation(Emulation.EmulatedDevice.Horizontal, Common.UIString('Landscape'));
     contextMenu.show();
 
     /**
      * @param {string} orientation
      * @param {string} title
      */
     function addOrientation(orientation, title) {
       var modes = device.modesForOrientation(orientation);
       if (!modes.length)
         return;
       if (modes.length === 1) {
         addMode(modes[0], title);
       } else {
         for (var index = 0; index < modes.length; index++)
           addMode(modes[index], title + ' \u2013 ' + modes[index].title);
       }
     }
 
     /**
-     * @param {!WebInspector.EmulatedDevice.Mode} mode
+     * @param {!Emulation.EmulatedDevice.Mode} mode
      * @param {string} title
      */
     function addMode(mode, title) {
       contextMenu.appendCheckboxItem(title, applyMode.bind(null, mode), model.mode() === mode, false);
     }
 
     /**
-     * @param {!WebInspector.EmulatedDevice.Mode} mode
+     * @param {!Emulation.EmulatedDevice.Mode} mode
      */
     function applyMode(mode) {
       model.emulate(model.type(), model.device(), mode);
     }
   }
 
   /**
    * @return {!Element}
    */
   element() {
     return this._element;
   }
 
   update() {
     if (this._model.type() !== this._cachedModelType) {
       this._cachedModelType = this._model.type();
-      this._widthInput.disabled = this._model.type() !== WebInspector.DeviceModeModel.Type.Responsive;
-      this._heightInput.disabled = this._model.type() !== WebInspector.DeviceModeModel.Type.Responsive;
-      this._deviceScaleItem.setEnabled(this._model.type() === WebInspector.DeviceModeModel.Type.Responsive);
-      this._uaItem.setEnabled(this._model.type() === WebInspector.DeviceModeModel.Type.Responsive);
+      this._widthInput.disabled = this._model.type() !== Emulation.DeviceModeModel.Type.Responsive;
+      this._heightInput.disabled = this._model.type() !== Emulation.DeviceModeModel.Type.Responsive;
+      this._deviceScaleItem.setEnabled(this._model.type() === Emulation.DeviceModeModel.Type.Responsive);
+      this._uaItem.setEnabled(this._model.type() === Emulation.DeviceModeModel.Type.Responsive);
     }
 
     var size = this._model.appliedDeviceSize();
     this._updateHeightInput(
-        this._model.type() === WebInspector.DeviceModeModel.Type.Responsive && this._model.isFullHeight() ?
+        this._model.type() === Emulation.DeviceModeModel.Type.Responsive && this._model.isFullHeight() ?
             '' :
             String(size.height));
     this._updateWidthInput(String(size.width));
     this._heightInput.placeholder = size.height;
 
     if (this._model.scale() !== this._cachedScale) {
-      this._scaleItem.setText(WebInspector.UIString('%.0f%%', this._model.scale() * 100));
+      this._scaleItem.setText(Common.UIString('%.0f%%', this._model.scale() * 100));
       this._cachedScale = this._model.scale();
     }
 
     var deviceScale = this._model.appliedDeviceScaleFactor();
     if (deviceScale !== this._cachedDeviceScale) {
-      this._deviceScaleItem.setText(WebInspector.UIString('DPR: %.1f', deviceScale));
+      this._deviceScaleItem.setText(Common.UIString('DPR: %.1f', deviceScale));
       this._cachedDeviceScale = deviceScale;
     }
 
     var uaType = this._model.appliedUserAgentType();
     if (uaType !== this._cachedUaType) {
       this._uaItem.setText(uaType);
       this._cachedUaType = uaType;
     }
 
-    var deviceItemTitle = WebInspector.UIString('None');
-    if (this._model.type() === WebInspector.DeviceModeModel.Type.Responsive)
-      deviceItemTitle = WebInspector.UIString('Responsive');
-    if (this._model.type() === WebInspector.DeviceModeModel.Type.Device)
+    var deviceItemTitle = Common.UIString('None');
+    if (this._model.type() === Emulation.DeviceModeModel.Type.Responsive)
+      deviceItemTitle = Common.UIString('Responsive');
+    if (this._model.type() === Emulation.DeviceModeModel.Type.Device)
       deviceItemTitle = this._model.device().title;
     this._deviceSelectItem.setText(deviceItemTitle);
 
     if (this._model.device() !== this._cachedModelDevice) {
       var device = this._model.device();
       this._modeButton.setVisible(!!device);
       if (device) {
         var modeCount = device ? device.modes.length : 0;
         this._modeButton.setEnabled(modeCount >= 2);
         this._modeButton.setTitle(
-            modeCount === 2 ? WebInspector.UIString('Rotate') : WebInspector.UIString('Screen options'));
+            modeCount === 2 ? Common.UIString('Rotate') : Common.UIString('Screen options'));
       }
       this._cachedModelDevice = device;
     }
 
-    if (this._model.type() === WebInspector.DeviceModeModel.Type.Device)
+    if (this._model.type() === Emulation.DeviceModeModel.Type.Device)
       this._lastMode.set(
-          /** @type {!WebInspector.EmulatedDevice} */ (this._model.device()),
-          /** @type {!WebInspector.EmulatedDevice.Mode} */ (this._model.mode()));
+          /** @type {!Emulation.EmulatedDevice} */ (this._model.device()),
+          /** @type {!Emulation.EmulatedDevice.Mode} */ (this._model.mode()));
 
-    if (this._model.mode() !== this._cachedModelMode && this._model.type() !== WebInspector.DeviceModeModel.Type.None) {
+    if (this._model.mode() !== this._cachedModelMode && this._model.type() !== Emulation.DeviceModeModel.Type.None) {
       this._cachedModelMode = this._model.mode();
       var value = this._persistenceSetting.get();
       if (this._model.device()) {
         value.device = this._model.device().title;
         value.orientation = this._model.mode() ? this._model.mode().orientation : '';
         value.mode = this._model.mode() ? this._model.mode().title : '';
       } else {
         value.device = '';
         value.orientation = '';
         value.mode = '';
       }
       this._persistenceSetting.set(value);
     }
   }
 
   restore() {
     for (var device of this._allDevices()) {
       if (device.title === this._persistenceSetting.get().device) {
         for (var mode of device.modes) {
           if (mode.orientation === this._persistenceSetting.get().orientation &&
               mode.title === this._persistenceSetting.get().mode) {
             this._lastMode.set(device, mode);
             this._emulateDevice(device);
             return;
           }
         }
       }
     }
 
-    this._model.emulate(WebInspector.DeviceModeModel.Type.Responsive, null, null);
+    this._model.emulate(Emulation.DeviceModeModel.Type.Responsive, null, null);
   }
 };