[DevTools] Rename "emulateViewport" to "mobile".

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 20 matching lines @@
 /**
  * @constructor
  * @implements {WebInspector.TargetManager.Observer}
  * @extends {WebInspector.Object}
  * @param {boolean} responsiveDesignAvailable
  */
 WebInspector.OverridesSupport = function(responsiveDesignAvailable)
 {
     WebInspector.resourceTreeModel.addEventListener(WebInspector.ResourceTreeModel.EventTypes.MainFrameNavigated, this._onMainFrameNavigated.bind(this), this);
     this._touchEmulationSuspended = false;
-    this._emulateViewportEnabled = false;
+    this._emulateMobileEnabled = false;
     this._userAgent = "";
     this._pageResizer = null;
     this._deviceScale = 1;
     this._fixedDeviceScale = false;
     this._initialized = false;
     this._deviceMetricsThrottler = new WebInspector.Throttler(0);
     this._responsiveDesignAvailable = responsiveDesignAvailable;
     WebInspector.targetManager.observeTargets(this);
 }
 
@@ skipping 34 matching lines @@
  * @param {string} userAgent
  * @constructor
  */
 WebInspector.OverridesSupport.Device = function(description, userAgent)
 {
     this.width = 800;
     this.height = 600;
     this.deviceScaleFactor = 1;
     this.userAgent = userAgent;
     this.touch = true;
-    this.viewport = true;
+    this.mobile = true;
 
     var splitMetrics = description.split("x");
     if (splitMetrics.length >= 3) {
         this.width = parseInt(splitMetrics[0], 10);
         this.height = parseInt(splitMetrics[1], 10);
         this.deviceScaleFactor = parseFloat(splitMetrics[2]);
     }
     if (splitMetrics.length >= 4)
         this.touch = splitMetrics[3] == 1;
     if (splitMetrics.length >= 5)
-        this.viewport = splitMetrics[4] == 1;
+        this.mobile = splitMetrics[4] == 1;
 }
 
 /**
  * @constructor
  * @param {number} latitude
  * @param {number} longitude
  * @param {string} error
  */
 WebInspector.OverridesSupport.GeolocationPosition = function(latitude, longitude, error)
 {
@@ skipping 150 matching lines @@
         return "";
     return WebInspector.UIString("Value must be non-negative float");
 }
 
 // Second element is user agent value.
 // Third element lists device metrics separated by 'x':
 // - screen width,
 // - screen height,
 // - device scale factor,
 // - touch (true by default if not present),
-// - viewport (true by default if not present).
+// - mobile (true by default if not present).
 WebInspector.OverridesSupport._phones = [
     ["Apple iPhone 3GS",
      "Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_2_1 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8C148 Safari/6533.18.5",
      "320x480x1"],
     ["Apple iPhone 4",
      "Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_2_1 like Mac OS X; en-us) AppleWebKit/533.17.9 (KHTML, like Gecko) Version/5.0.2 Mobile/8C148 Safari/6533.18.5",
      "320x480x2"],
     ["Apple iPhone 5",
      "Mozilla/5.0 (iPhone; CPU iPhone OS 7_0 like Mac OS X; en-us) AppleWebKit/537.51.1 (KHTML, like Gecko) Version/7.0 Mobile/11A465 Safari/9537.53",
      "320x568x2"],
@@ skipping 211 matching lines @@
     emulateDevice: function(device)
     {
         this._deviceMetricsChangedListenerMuted = true;
         this._userAgentChangedListenerMuted = true;
         this.settings.userAgent.set(device.userAgent);
         this.settings.emulateResolution.set(true);
         this.settings.deviceWidth.set(device.width);
         this.settings.deviceHeight.set(device.height);
         this.settings.deviceScaleFactor.set(device.deviceScaleFactor);
         this.settings.emulateTouch.set(device.touch);
-        this.settings.emulateViewport.set(device.viewport);
+        this.settings.emulateMobile.set(device.mobile);
         delete this._deviceMetricsChangedListenerMuted;
         delete this._userAgentChangedListenerMuted;
 
         if (this._initialized) {
             this._deviceMetricsChanged();
             this._userAgentChanged();
             PageAgent.resetScrollAndPageScaleFactor();
         }
     },
 
     reset: function()
     {
         this._deviceMetricsChangedListenerMuted = true;
         this._userAgentChangedListenerMuted = true;
         this.settings.userAgent.set("");
         this.settings.emulateResolution.set(false);
         this.settings.deviceScaleFactor.set(0);
         this.settings.emulateTouch.set(false);
-        this.settings.emulateViewport.set(false);
+        this.settings.emulateMobile.set(false);
         this.settings.overrideDeviceOrientation.set(false);
         this.settings.overrideGeolocation.set(false);
         this.settings.overrideCSSMedia.set(false);
         this.settings.networkConditions.set({throughput: WebInspector.OverridesSupport._networkThroughputUnlimitedValue, latency: 0});
         delete this._deviceMetricsChangedListenerMuted;
         delete this._userAgentChangedListenerMuted;
 
         if (this._initialized) {
             this._deviceMetricsChanged();
             this._userAgentChanged();
         }
     },
 
     /**
      * @param {!WebInspector.OverridesSupport.Device} device
      * @return {boolean}
      */
     isEmulatingDevice: function(device)
     {
         return this.settings.userAgent.get() === device.userAgent
             && this.settings.deviceWidth.get() === device.width
             && this.settings.deviceHeight.get() === device.height
             && this.settings.deviceScaleFactor.get() === device.deviceScaleFactor
             && this.settings.emulateTouch.get() === device.touch
-            && this.settings.emulateViewport.get() === device.viewport
+            && this.settings.emulateMobile.get() === device.mobile
             && this.settings.emulateResolution.get();
     },
 
     /**
      * @param {boolean} suspended
      */
     setTouchEmulationSuspended: function(suspended)
     {
         this._touchEmulationSuspended = suspended;
         if (this._initialized)
@@ skipping 10 matching lines @@
         this._initialized = true;
 
         this.settings._emulationEnabled.addChangeListener(this._userAgentChanged, this);
         this.settings.userAgent.addChangeListener(this._userAgentChanged, this);
 
         this.settings._emulationEnabled.addChangeListener(this._deviceMetricsChanged, this);
         this.settings.emulateResolution.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.emulateViewport.addChangeListener(this._deviceMetricsChanged, this);
+        this.settings.emulateMobile.addChangeListener(this._deviceMetricsChanged, this);
         this.settings.deviceFitWindow.addChangeListener(this._deviceMetricsChanged, this);
 
         this.settings._emulationEnabled.addChangeListener(this._geolocationPositionChanged, this);
         this.settings.overrideGeolocation.addChangeListener(this._geolocationPositionChanged, this);
         this.settings.geolocationOverride.addChangeListener(this._geolocationPositionChanged, this);
 
         this.settings._emulationEnabled.addChangeListener(this._deviceOrientationChanged, this);
         this.settings.overrideDeviceOrientation.addChangeListener(this._deviceOrientationChanged, this);
         this.settings.deviceOrientationOverride.addChangeListener(this._deviceOrientationChanged, this);
 
@@ skipping 132 matching lines @@
         this._deviceMetricsThrottler.schedule(setDeviceMetricsOverride.bind(this));
 
         /**
          * @param {!WebInspector.Throttler.FinishCallback} finishCallback
          * @this {WebInspector.OverridesSupport}
          */
         function setDeviceMetricsOverride(finishCallback)
         {
             PageAgent.setDeviceMetricsOverride(
                 overrideWidth, overrideHeight, this.settings.deviceScaleFactor.get(),
-                this.settings.emulateViewport.get(), this._pageResizer ? false : this.settings.deviceFitWindow.get(), scale, 0, 0,
+                this.settings.emulateMobile.get(), this._pageResizer ? false : this.settings.deviceFitWindow.get(), scale, 0, 0,
                 apiCallback.bind(this, finishCallback));
         }
 
         /**
          * @param {!WebInspector.Throttler.FinishCallback} finishCallback
          * @this {WebInspector.OverridesSupport}
          */
         function clearDeviceMetricsOverride(finishCallback)
         {
             PageAgent.clearDeviceMetricsOverride(apiCallback.bind(this, finishCallback));
         }
 
         /**
          * @param {!WebInspector.Throttler.FinishCallback} finishCallback
          * @param {?Protocol.Error} error
          * @this {WebInspector.OverridesSupport}
          */
         function apiCallback(finishCallback, error)
         {
             if (error) {
                 this._updateDeviceMetricsWarningMessage(WebInspector.UIString("Screen emulation is not available on this page."));
                 this._deviceMetricsOverrideAppliedForTest();
                 finishCallback();
                 return;
             }
 
-            var viewportEnabled = this.emulationEnabled() && this.settings.emulateViewport.get();
-            if (this._emulateViewportEnabled !== viewportEnabled)
+            var mobileEnabled = this.emulationEnabled() && this.settings.emulateMobile.get();
+            if (this._emulateMobileEnabled !== mobileEnabled)
                 this._updateDeviceMetricsWarningMessage(WebInspector.UIString("You might need to reload the page for proper user agent spoofing and viewport rendering."));
-            this._emulateViewportEnabled = viewportEnabled;
+            this._emulateMobileEnabled = mobileEnabled;
             this._deviceMetricsOverrideAppliedForTest();
             finishCallback();
         }
     },
 
     _deviceMetricsOverrideAppliedForTest: function()
     {
         // Used for sniffing in tests.
     },
 
@@ skipping 136 matching lines @@
         this.settings = {};
         this.settings._emulationEnabled = WebInspector.settings.createSetting("emulationEnabled", false);
 
         this.settings.userAgent = WebInspector.settings.createSetting("userAgent", "");
 
         this.settings.emulateResolution = WebInspector.settings.createSetting("emulateResolution", true);
         this.settings.deviceWidth = WebInspector.settings.createSetting("deviceWidth", 360);
         this.settings.deviceHeight = WebInspector.settings.createSetting("deviceHeight", 640);
         this.settings.deviceScaleFactor = WebInspector.settings.createSetting("deviceScaleFactor", 0);
         this.settings.deviceFitWindow = WebInspector.settings.createSetting("deviceFitWindow", true);
-        // FIXME: rename viewport to mobile everywhere in the code.
-        this.settings.emulateViewport = WebInspector.settings.createSetting("emulateViewport", false);
+        this.settings.emulateMobile = WebInspector.settings.createSetting("emulateMobile", false);
 
         this.settings.emulateTouch = WebInspector.settings.createSetting("emulateTouch", 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);
@@ skipping 73 matching lines @@
             }
         }
 
         deviceSelectElement.addEventListener("change", deviceSelected, false);
 
         var emulatedSettingChangedMuted = false;
         WebInspector.overridesSupport.settings.emulateResolution.addChangeListener(emulatedSettingChanged);
         WebInspector.overridesSupport.settings.deviceWidth.addChangeListener(emulatedSettingChanged);
         WebInspector.overridesSupport.settings.deviceHeight.addChangeListener(emulatedSettingChanged);
         WebInspector.overridesSupport.settings.deviceScaleFactor.addChangeListener(emulatedSettingChanged);
-        WebInspector.overridesSupport.settings.emulateViewport.addChangeListener(emulatedSettingChanged);
+        WebInspector.overridesSupport.settings.emulateMobile.addChangeListener(emulatedSettingChanged);
         WebInspector.overridesSupport.settings.emulateTouch.addChangeListener(emulatedSettingChanged);
         WebInspector.overridesSupport.settings.userAgent.addChangeListener(emulatedSettingChanged);
         emulatedSettingChanged();
 
         function deviceSelected()
         {
             if (deviceSelectElement.selectedIndex === 0)
                 return;
 
             var option = deviceSelectElement.options[deviceSelectElement.selectedIndex];
@@ skipping 91 matching lines @@
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 
 /**
  * @type {!WebInspector.OverridesSupport}
  */
 WebInspector.overridesSupport;