DevTools: get rid of deviceMetics settings.

Source/devtools/front_end/sdk/OverridesSupport.js

 /*
  * Copyright (C) 2012 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 18 matching lines @@
  */
 
 /**
  * @constructor
  * @implements {WebInspector.TargetManager.Observer}
  * @extends {WebInspector.Object}
  */
 WebInspector.OverridesSupport = function()
 {
     WebInspector.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.MainFrameNavigated, this._onMainFrameNavigated.bind(this), this);
-    this._deviceMetricsOverrideEnabled = false;
+    this._overrideDeviceResolution = false;
     this._emulateViewportEnabled = false;
     this._userAgent = "";
     this._pageResizer = null;
     WebInspector.targetManager.observeTargets(this);
 }
 
 WebInspector.OverridesSupport.Events = {
     OverridesWarningUpdated: "OverridesWarningUpdated",
     HasActiveOverridesChanged: "HasActiveOverridesChanged",
 }
@@ skipping 12 matching lines @@
 };
 
 WebInspector.OverridesSupport.PageResizer.prototype = {
     /**
      * Zero width and height mean default size.
      * Scale should be applied to page-scale-dependent UI bits. Zero means no scale.
      * @param {number} dipWidth
      * @param {number} dipHeight
      * @param {number} scale
      */
-    enable: function(dipWidth, dipHeight, scale) { },
-
-    disable: function() { },
+    update: function(dipWidth, dipHeight, scale) { },
 
     /**
      * Available size for the page.
      * @return {!Size}
      */
     availableDipSize: function() { }
 };
 
 /**
  * @constructor
@@ skipping 26 matching lines @@
             height = parseInt(splitMetrics[1], 10);
             deviceScaleFactor = parseFloat(splitMetrics[2]);
             if (splitMetrics.length == 4)
                 textAutosizing = splitMetrics[3] == 1;
         }
     }
     return new WebInspector.OverridesSupport.DeviceMetrics(width, height, deviceScaleFactor, textAutosizing);
 }
 
 /**
- * @return {?WebInspector.OverridesSupport.DeviceMetrics}
- */
-WebInspector.OverridesSupport.DeviceMetrics._parseUserInput = function(widthString, heightString, deviceScaleFactorString, textAutosizing)
-{
-    function isUserInputValid(value, isInteger)
-    {
-        if (!value)
-            return true;
-        return isInteger ? /^[\d]+$/.test(value) : /^[\d]+(\.\d+)?|\.\d+$/.test(value);
-    }
-
-    if (!widthString ^ !heightString)
-        return null;
-
-    var isWidthValid = isUserInputValid(widthString, true);
-    var isHeightValid = isUserInputValid(heightString, true);
-    var isDeviceScaleFactorValid = isUserInputValid(deviceScaleFactorString, false);
-
-    if (!isWidthValid && !isHeightValid && !isDeviceScaleFactorValid)
-        return null;
-
-    var width = isWidthValid ? parseInt(widthString || "0", 10) : -1;
-    var height = isHeightValid ? parseInt(heightString || "0", 10) : -1;
-    var deviceScaleFactor = isDeviceScaleFactorValid ? parseFloat(deviceScaleFactorString) : -1;
-
-    return new WebInspector.OverridesSupport.DeviceMetrics(width, height, deviceScaleFactor, textAutosizing);
-}
-
-/**
- * @param {!Element} widthInput
- * @param {!Element} heightInput
- * @param {!Element} deviceScaleFactorInput
- * @param {!Element} textAutosizingInput
- */
-WebInspector.OverridesSupport.DeviceMetrics.applyOverrides = function(widthInput, heightInput, deviceScaleFactorInput, textAutosizingInput)
-{
-    if (WebInspector.OverridesSupport.DeviceMetrics._applyOverridesTimer)
-        clearTimeout(WebInspector.OverridesSupport.DeviceMetrics._applyOverridesTimer);
-    WebInspector.OverridesSupport.DeviceMetrics._applyOverridesTimer = setTimeout(onTimer, 50);
-
-    function onTimer()
-    {
-        delete WebInspector.OverridesSupport.DeviceMetrics._applyOverridesTimer;
-        var metrics = WebInspector.OverridesSupport.DeviceMetrics._parseUserInput(widthInput.value.trim(), heightInput.value.trim(), deviceScaleFactorInput.value.trim(), textAutosizingInput.checked);
-
-        function setValid(condition, element)
-        {
-            if (condition)
-                element.classList.remove("error-input");
-            else
-                element.classList.add("error-input");
-        }
-
-        setValid(metrics && metrics.isWidthValid(), widthInput);
-        setValid(metrics && metrics.isHeightValid(), heightInput);
-        setValid(metrics && metrics.isDeviceScaleFactorValid(), deviceScaleFactorInput);
-
-        if (!metrics)
-            return;
-
-        if (metrics.isValid()) {
-            var value = metrics.toSetting();
-            if (value !== WebInspector.overridesSupport.settings.deviceMetrics.get())
-                WebInspector.overridesSupport.settings.deviceMetrics.set(value);
-        }
-    }
-}
-
-WebInspector.OverridesSupport.DeviceMetrics.prototype = {
-    /**
-     * @return {boolean}
-     */
-    isValid: function()
-    {
-        return this.isWidthValid() && this.isHeightValid() && this.isDeviceScaleFactorValid();
-    },
-
-    /**
-     * @return {boolean}
-     */
-    isWidthValid: function()
-    {
-        return this.width >= 0;
-    },
-
-    /**
-     * @return {boolean}
-     */
-    isHeightValid: function()
-    {
-        return this.height >= 0;
-    },
-
-    /**
-     * @return {boolean}
-     */
-    isDeviceScaleFactorValid: function()
-    {
-        return this.deviceScaleFactor >= 0;
-    },
-
-    /**
-     * @return {string}
-     */
-    toSetting: function()
-    {
-        if (!this.isValid())
-            return "";
-
-        return this.width + "x" + this.height + "x" + this.deviceScaleFactor + "x" + (this.textAutosizing ? "1" : "0");
-    },
-
-    /**
-     * @return {string}
-     */
-    widthToInput: function()
-    {
-        return this.isWidthValid() ? String(this.width) : "";
-    },
-
-    /**
-     * @return {string}
-     */
-    heightToInput: function()
-    {
-        return this.isHeightValid() ? String(this.height) : "";
-    },
-
-    /**
-     * @return {string}
-     */
-    deviceScaleFactorToInput: function()
-    {
-        return this.isDeviceScaleFactorValid() ? String(this.deviceScaleFactor) : "";
-    },
-
-    /**
-     * Compute the font scale factor.
-     *
-     * Chromium on Android uses a device scale adjustment for fonts used in text autosizing for
-     * improved legibility. This function computes this adjusted value for text autosizing.
-     *
-     * For a description of the Android device scale adjustment algorithm, see:
-     *     chrome/browser/chrome_content_browser_client.cc, GetFontScaleMultiplier(...)
-     *
-     * @return {number} font scale factor.
-     */
-    fontScaleFactor: function()
-    {
-        if (this.isValid()) {
-            // FIXME: this works bad with zero width/height. Create utility function with parameters instead.
-            var minWidth = Math.min(this.width, this.height) / (this.deviceScaleFactor || 1);
-
-            var kMinFSM = 1.05;
-            var kWidthForMinFSM = 320;
-            var kMaxFSM = 1.3;
-            var kWidthForMaxFSM = 800;
-
-            if (minWidth <= kWidthForMinFSM)
-                return kMinFSM;
-            if (minWidth >= kWidthForMaxFSM)
-                return kMaxFSM;
-
-            // The font scale multiplier varies linearly between kMinFSM and kMaxFSM.
-            var ratio = (minWidth - kWidthForMinFSM) / (kWidthForMaxFSM - kWidthForMinFSM);
-
-            return ratio * (kMaxFSM - kMinFSM) + kMinFSM;
-        }
-
-        return 1;
-    }
-}
-
-/**
  * @constructor
  * @param {number} latitude
  * @param {number} longitude
  */
 WebInspector.OverridesSupport.GeolocationPosition = function(latitude, longitude, error)
 {
     this.latitude = latitude;
     this.longitude = longitude;
     this.error = error;
 }
@@ skipping 118 matching lines @@
     var gamma = isGammaValid ? parseFloat(gammaString) : -1;
 
     return new WebInspector.OverridesSupport.DeviceOrientation(alpha, beta, gamma);
 }
 
 WebInspector.OverridesSupport.DeviceOrientation.clearDeviceOrientationOverride = function()
 {
     PageAgent.clearDeviceOrientationOverride();
 }
 
+/**
+ * @param {string} value
+ */
+WebInspector.OverridesSupport.inputValidator = function(value)
+{
+    if (value >= 0 && value <= 10000)
+        return "";
+    return WebInspector.UIString("Value must be non-negative integer");
+}
+
+
 WebInspector.OverridesSupport.prototype = {
     /**
      * @param {?WebInspector.OverridesSupport.PageResizer} pageResizer
      */
     setPageResizer: function(pageResizer)
     {
         if (pageResizer === this._pageResizer)
             return;
 
         if (this._pageResizer) {
-            this._pageResizer.disable();
             this._pageResizer.removeEventListener(WebInspector.OverridesSupport.PageResizer.Events.AvailableSizeChanged, this._onPageResizerAvailableSizeChanged, this);
             this._pageResizer.removeEventListener(WebInspector.OverridesSupport.PageResizer.Events.ResizeRequested, this._onPageResizerResizeRequested, this);
         }
         this._pageResizer = pageResizer;
         if (this._pageResizer) {
             this._pageResizer.addEventListener(WebInspector.OverridesSupport.PageResizer.Events.AvailableSizeChanged, this._onPageResizerAvailableSizeChanged, this);
             this._pageResizer.addEventListener(WebInspector.OverridesSupport.PageResizer.Events.ResizeRequested, this._onPageResizerResizeRequested, this);
         }
         this._deviceMetricsChanged();
     },
 
     /**
      * @param {string} deviceMetrics
      * @param {string} userAgent
      */
     emulateDevice: function(deviceMetrics, userAgent)
     {
+        var metrics = WebInspector.OverridesSupport.DeviceMetrics.parseSetting(deviceMetrics);
         this._deviceMetricsChangedListenerMuted = true;
         this._userAgentChangedListenerMuted = true;
-        this.settings.deviceMetrics.set(deviceMetrics);
         this.settings.userAgent.set(userAgent);
-        this.settings.overrideDeviceMetrics.set(true);
+        this.settings.overrideDeviceResolution.set(true);
+        this.settings.deviceWidth.set(metrics.width);
+        this.settings.deviceHeight.set(metrics.height);
+        this.settings.deviceScaleFactor.set(metrics.deviceScaleFactor);
+        this.settings.deviceTextAutosizing.set(metrics.textAutosizing);
         this.settings.overrideUserAgent.set(true);
         this.settings.emulateTouchEvents.set(true);
         this.settings.emulateViewport.set(true);
         delete this._deviceMetricsChangedListenerMuted;
         delete this._userAgentChangedListenerMuted;
         this._deviceMetricsChanged();
         this._userAgentChanged();
     },
 
     reset: function()
     {
         this._deviceMetricsChangedListenerMuted = true;
         this._userAgentChangedListenerMuted = true;
-        this.settings.overrideDeviceMetrics.set(false);
+        this.settings.overrideDeviceResolution.set(false);
         this.settings.overrideUserAgent.set(false);
         this.settings.emulateTouchEvents.set(false);
         this.settings.overrideDeviceOrientation.set(false);
         this.settings.overrideGeolocation.set(false);
         this.settings.overrideCSSMedia.set(false);
         this.settings.emulateViewport.set(false);
-        this.settings.deviceMetrics.set("");
         delete this._deviceMetricsChangedListenerMuted;
         delete this._userAgentChangedListenerMuted;
         this._deviceMetricsChanged();
         this._userAgentChanged();
     },
 
     applyInitialOverrides: function()
     {
         if (!this._target) {
             this._applyInitialOverridesOnTargetAdded = true;
             return;
         }
 
         if (this.settings.overrideDeviceOrientation.get())
             this._deviceOrientationChanged();
 
         if (this.settings.overrideGeolocation.get())
             this._geolocationPositionChanged();
 
         if (this.settings.emulateTouchEvents.get())
             this._emulateTouchEventsChanged();
 
         if (this.settings.overrideCSSMedia.get())
             this._cssMediaChanged();
 
-        if (this.settings.overrideDeviceMetrics.get())
+        if (this.settings.overrideDeviceResolution.get() || this.settings.emulateViewport.get())
             this._deviceMetricsChanged();
 
         if (this.settings.overrideUserAgent.get())
             this._userAgentChanged();
 
         this._showRulersChanged();
     },
 
     _userAgentChanged: function()
     {
         if (this._userAgentChangedListenerMuted)
             return;
         var userAgent = this.settings.overrideUserAgent.get() ? this.settings.userAgent.get() : "";
         NetworkAgent.setUserAgentOverride(userAgent);
         this._updateUserAgentWarningMessage(this._userAgent !== userAgent ? WebInspector.UIString("You might need to reload the page for proper user agent spoofing and viewport rendering.") : "");
         this._userAgent = userAgent;
         this.maybeHasActiveOverridesChanged();
     },
 
     _onPageResizerAvailableSizeChanged: function()
     {
-        var metrics = WebInspector.OverridesSupport.DeviceMetrics.parseSetting(this.settings.deviceMetrics.get());
-        if (!metrics.isValid())
-            return;
-
-        var available = this._pageResizer.availableDipSize();
-        if (available.width > metrics.width && available.height > metrics.height)
-            return;
-
         this._deviceMetricsChanged();
     },
 
     _onPageResizerResizeRequested: function(event)
     {
-        if (!this.settings.overrideDeviceMetrics.get())
-            return;
-
         var size = /** @type {!Size} */ (event.data);
-        var metrics = WebInspector.OverridesSupport.DeviceMetrics.parseSetting(this.settings.deviceMetrics.get());
-        if (!metrics.isValid())
-            return;
-
-        metrics.width = size.width;
-        metrics.height = size.height;
-        var value = metrics.toSetting();
-        if (this.settings.deviceMetrics.get() === value)
-            return;
-
-        this.settings.deviceMetrics.set(metrics.toSetting());
+        if (size.width !== this.settings.deviceWidth.get())
+            this.settings.deviceWidth.set(size.width);
+        if (size.height !== this.settings.deviceHeight.get())
+            this.settings.deviceHeight.set(size.height);
     },
 
     _deviceMetricsChanged: function()
     {
         this._showRulersChanged();
 
         if (this._deviceMetricsChangedListenerMuted)
             return;
 
-        var metricsOverrideEnabled = this.settings.overrideDeviceMetrics.get();
-        if (!metricsOverrideEnabled) {
+        var overrideDeviceResolution = this.settings.overrideDeviceResolution.get();
+        if (!overrideDeviceResolution && !this.settings.emulateViewport.get()) {
+            PageAgent.clearDeviceMetricsOverride(apiCallback.bind(this));
             if (this._pageResizer)
-                this._pageResizer.disable();
-            PageAgent.clearDeviceMetricsOverride(apiCallback.bind(this));
+                this._pageResizer.update(0, 0, 0);
             this.maybeHasActiveOverridesChanged();
             return;
         }
 
-        var metrics = WebInspector.OverridesSupport.DeviceMetrics.parseSetting(this.settings.deviceMetrics.get());
-        if (!metrics.isValid())
-            return;
-
-        var dipWidth = Math.round(metrics.width);
-        var dipHeight = Math.round(metrics.height);
+        var dipWidth = overrideDeviceResolution ? this.settings.deviceWidth.get() : 0;
+        var dipHeight = overrideDeviceResolution ? this.settings.deviceHeight.get() : 0;
 
         // Disable override without checks.
         if (this.isInspectingDevice())
             return;
 
         var overrideWidth = dipWidth;
         var overrideHeight = dipHeight;
         if (this._pageResizer) {
             var available = this._pageResizer.availableDipSize();
             if (available.width >= dipWidth && available.height >= dipHeight) {
-                this._pageResizer.enable(dipWidth, dipHeight, 0);
+                this._pageResizer.update(dipWidth, dipHeight, 0);
                 // When we have enough space, no page size override is required. This will speed things up and remove lag.
                 overrideWidth = 0;
                 overrideHeight = 0;
             } else {
-                this._pageResizer.enable(Math.min(dipWidth, available.width), Math.min(dipHeight, available.height), 0);
+                this._pageResizer.update(Math.min(dipWidth, available.width), Math.min(dipHeight, available.height), 0);
             }
         }
 
         // Do not emulate resolution more often than 10Hz.
         this._setDeviceMetricsTimers = (this._setDeviceMetricsTimers || 0) + 1;
         if (overrideWidth || overrideHeight)
             setTimeout(setDeviceMetricsOverride.bind(this), 100);
         else
             setDeviceMetricsOverride.call(this);
 
         /**
          * @this {WebInspector.OverridesSupport}
          */
         function setDeviceMetricsOverride()
         {
             // Drop heavy intermediate commands.
             this._setDeviceMetricsTimers--;
             var isExpensive = overrideWidth || overrideHeight;
             if (isExpensive && this._setDeviceMetricsTimers) {
                 var commandThreshold = 100;
                 var time = window.performance.now();
                 if (time - this._lastExpensivePageAgentCommandTime < commandThreshold)
                     return;
                 this._lastExpensivePageAgentCommandTime = time;
             }
 
             PageAgent.setDeviceMetricsOverride(
-                overrideWidth, overrideHeight, metrics.deviceScaleFactor,
+                overrideWidth, overrideHeight, this.settings.deviceScaleFactor.get(),
                 this.settings.emulateViewport.get(), this._pageResizer ? false : this.settings.deviceFitWindow.get(),
-                metrics.textAutosizing, metrics.fontScaleFactor(),
+                this.settings.deviceTextAutosizing.get(), this._fontScaleFactor(overrideWidth || dipWidth, overrideHeight || dipHeight),
                 apiCallback.bind(this));
         }
 
         this.maybeHasActiveOverridesChanged();
 
         /**
          * @param {?Protocol.Error} error
          * @this {WebInspector.OverridesSupport}
          */
         function apiCallback(error)
         {
             if (error) {
                 this._updateDeviceMetricsWarningMessage(WebInspector.UIString("Screen emulation is not available on this page."));
-                if (this._pageResizer)
-                    this._pageResizer.disable();
+                this._deviceMetricsOverrideAppliedForTest();
                 return;
             }
 
-            var viewportEnabled =  this.settings.emulateViewport.get();
-            this._updateDeviceMetricsWarningMessage(this._deviceMetricsOverrideEnabled !== metricsOverrideEnabled || (metricsOverrideEnabled && this._emulateViewportEnabled != viewportEnabled) ?
+            var overrideDeviceResolution = this.settings.overrideDeviceResolution.get();
+            var viewportEnabled = this.settings.emulateViewport.get();
+            this._updateDeviceMetricsWarningMessage(this._overrideDeviceResolution !== overrideDeviceResolution || this._emulateViewportEnabled != viewportEnabled ?
                 WebInspector.UIString("You might need to reload the page for proper user agent spoofing and viewport rendering.") : "");
-            this._deviceMetricsOverrideEnabled = metricsOverrideEnabled;
+            this._overrideDeviceResolution = overrideDeviceResolution;
             this._emulateViewportEnabled = viewportEnabled;
             this._deviceMetricsOverrideAppliedForTest();
         }
     },
 
     _deviceMetricsOverrideAppliedForTest: function()
     {
         // Used for sniffing in tests.
     },
 
@@ skipping 45 matching lines @@
         for (var i = 0; i < targets.length; ++i)
             targets[i].cssModel.mediaQueryResultChanged();
         this.maybeHasActiveOverridesChanged();
     },
 
     /**
      * @return {boolean}
      */
     showMetricsRulers: function()
     {
-        var rulersInPageResizer = this._pageResizer && this.settings.overrideDeviceMetrics.get();
+        var rulersInPageResizer = this._pageResizer && this.settings.overrideDeviceResolution.get();
         return WebInspector.settings.showMetricsRulers.get() && !rulersInPageResizer;
     },
 
     _showRulersChanged: function()
     {
         if (WebInspector.experimentsSettings.responsiveDesign.isEnabled())
             return;
         PageAgent.setShowViewportSizeOnResize(true, this.showMetricsRulers());
     },
 
     /**
      * @return {boolean}
      */
     hasActiveOverrides: function()
     {
         return this._hasActiveOverrides;
     },
 
     maybeHasActiveOverridesChanged: function()
     {
         var hasActiveOverrides =
             this.settings.overrideUserAgent.get() ||
-            (this.settings.overrideDeviceMetrics.get() && !this.isInspectingDevice()) ||
+            ((this.settings.overrideDeviceResolution.get() || this.settings.emulateViewport.get()) && !this.isInspectingDevice()) ||
             this.settings.overrideGeolocation.get() ||
             this.settings.overrideDeviceOrientation.get() ||
             (this.settings.emulateTouchEvents.get() && !this.hasTouchInputs()) ||
             (this.settings.overrideCSSMedia.get() && !this.isInspectingDevice());
         if (this._hasActiveOverrides !== hasActiveOverrides) {
             this._hasActiveOverrides = hasActiveOverrides;
             this.dispatchEventToListeners(WebInspector.OverridesSupport.Events.HasActiveOverridesChanged);
         }
     },
 
@@ skipping 35 matching lines @@
     targetAdded: function(target)
     {
         // FIXME: adapt this to multiple targets.
         if (this._target)
             return;
         this._target = target;
 
         this.settings = {};
         this.settings.overrideUserAgent = WebInspector.settings.createSetting("overrideUserAgent", false);
         this.settings.userAgent = WebInspector.settings.createSetting("userAgent", "");
-        this.settings.overrideDeviceMetrics = WebInspector.settings.createSetting("overrideDeviceMetrics", false);
-        this.settings.deviceMetrics = WebInspector.settings.createSetting("deviceMetrics", "");
+
+        this.settings.overrideDeviceResolution = WebInspector.settings.createSetting("overrideDeviceResolution", false);
+        this.settings.deviceWidth = WebInspector.settings.createSetting("deviceWidth", 800);
+        this.settings.deviceHeight = WebInspector.settings.createSetting("deviceHeight", 600);
+        this.settings.deviceScaleFactor = WebInspector.settings.createSetting("deviceScaleFactor", window.devicePixelRatio);
+        this.settings.deviceTextAutosizing = WebInspector.settings.createSetting("deviceTextAutosizing", true);
+
         this.settings.deviceFitWindow = WebInspector.settings.createSetting("deviceFitWindow", true);
         this.settings.emulateViewport = WebInspector.settings.createSetting("emulateViewport", false);
         this.settings.emulateTouchEvents = WebInspector.settings.createSetting("emulateTouchEvents", false);
         this.settings.overrideGeolocation = WebInspector.settings.createSetting("overrideGeolocation", false);
         this.settings.geolocationOverride = WebInspector.settings.createSetting("geolocationOverride", "");
         this.settings.overrideDeviceOrientation = WebInspector.settings.createSetting("overrideDeviceOrientation", false);
         this.settings.deviceOrientationOverride = WebInspector.settings.createSetting("deviceOrientationOverride", "");
         this.settings.overrideCSSMedia = WebInspector.settings.createSetting("overrideCSSMedia", false);
         this.settings.emulatedCSSMedia = WebInspector.settings.createSetting("emulatedCSSMedia", "print");
 
         this.maybeHasActiveOverridesChanged();
 
         this.settings.overrideUserAgent.addChangeListener(this._userAgentChanged, this);
         this.settings.userAgent.addChangeListener(this._userAgentChanged, this);
 
-        this.settings.overrideDeviceMetrics.addChangeListener(this._deviceMetricsChanged, this);
-        this.settings.deviceMetrics.addChangeListener(this._deviceMetricsChanged, this);
+        this.settings.overrideDeviceResolution.addChangeListener(this._deviceMetricsChanged, this);
+        this.settings.deviceWidth.addChangeListener(this._deviceMetricsChanged, this);
+        this.settings.deviceHeight.addChangeListener(this._deviceMetricsChanged, this);
+        this.settings.deviceScaleFactor.addChangeListener(this._deviceMetricsChanged, this);
+        this.settings.deviceTextAutosizing.addChangeListener(this._deviceMetricsChanged, this);
         this.settings.emulateViewport.addChangeListener(this._deviceMetricsChanged, this);
         this.settings.deviceFitWindow.addChangeListener(this._deviceMetricsChanged, this);
 
         this.settings.overrideGeolocation.addChangeListener(this._geolocationPositionChanged, this);
         this.settings.geolocationOverride.addChangeListener(this._geolocationPositionChanged, this);
 
         this.settings.overrideDeviceOrientation.addChangeListener(this._deviceOrientationChanged, this);
         this.settings.deviceOrientationOverride.addChangeListener(this._deviceOrientationChanged, this);
 
         this.settings.emulateTouchEvents.addChangeListener(this._emulateTouchEventsChanged, this);
 
         this.settings.overrideCSSMedia.addChangeListener(this._cssMediaChanged, this);
         this.settings.emulatedCSSMedia.addChangeListener(this._cssMediaChanged, this);
 
         WebInspector.settings.showMetricsRulers.addChangeListener(this._showRulersChanged, this);
 
         if (this._applyInitialOverridesOnTargetAdded) {
             delete this._applyInitialOverridesOnTargetAdded;
             this.applyInitialOverrides();
         }
     },
 
+    swapDimensions: function()
+    {
+        var width = WebInspector.overridesSupport.settings.deviceWidth.get();
+        var height = WebInspector.overridesSupport.settings.deviceHeight.get();
+        WebInspector.overridesSupport.settings.deviceWidth.set(height);
+        WebInspector.overridesSupport.settings.deviceHeight.set(width);
+    },
+
     /**
      * @param {!WebInspector.Target} target
      */
     targetRemoved: function(target)
     {
         // FIXME: adapt this to multiple targets.
     },
 
     /**
      * @return {boolean}
      */
     isInspectingDevice: function()
     {
         return !!this._target && this._target.isMobile();
     },
 
     /**
      * @return {boolean}
      */
     hasTouchInputs: function()
     {
         return !!this._target && this._target.hasTouchInputs;
     },
 
+    /**
+     * Compute the font scale factor.
+     *
+     * Chromium on Android uses a device scale adjustment for fonts used in text autosizing for
+     * improved legibility. This function computes this adjusted value for text autosizing.
+     *
+     * For a description of the Android device scale adjustment algorithm, see:
+     *     chrome/browser/chrome_content_browser_client.cc, GetFontScaleMultiplier(...)
+     *
+     * @param {number} width
+     * @param {number} height
+     * @return {number} font scale factor.
+     */
+    _fontScaleFactor: function(width, height)
+    {
+        if (!this.settings.overrideDeviceResolution.get())
+            return 1;
+        if (!width && !height)
+            return 1;
+
+        var deviceScaleFactor = this.settings.deviceScaleFactor.get();
+
+        var minWidth = Math.min(width, height) / deviceScaleFactor;
+
+        var kMinFSM = 1.05;
+        var kWidthForMinFSM = 320;
+        var kMaxFSM = 1.3;
+        var kWidthForMaxFSM = 800;
+
+        if (minWidth <= kWidthForMinFSM)
+            return kMinFSM;
+        if (minWidth >= kWidthForMaxFSM)
+            return kMaxFSM;
+
+        // The font scale multiplier varies linearly between kMinFSM and kMaxFSM.
+        var ratio = (minWidth - kWidthForMinFSM) / (kWidthForMaxFSM - kWidthForMinFSM);
+        return ratio * (kMaxFSM - kMinFSM) + kMinFSM;
+    },
+
     __proto__: WebInspector.Object.prototype
 }
 
 
 /**
  * @type {!WebInspector.OverridesSupport}
  */
 WebInspector.overridesSupport;