DevTools: move emulation button into the base App.js.

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 30 matching lines @@
     this._userAgent = "";
     this._pageResizer = null;
     this._initialized = false;
     this._deviceMetricsThrottler = new WebInspector.Throttler(0);
     this._responsiveDesignAvailable = responsiveDesignAvailable;
     WebInspector.targetManager.observeTargets(this);
 }
 
 WebInspector.OverridesSupport.Events = {
     OverridesWarningUpdated: "OverridesWarningUpdated",
-    HasActiveOverridesChanged: "HasActiveOverridesChanged",
+    EmulationStateChanged: "EmulationStateChanged"
 }
 
 /**
  * @interface
  * @extends {WebInspector.EventTarget}
  */
 WebInspector.OverridesSupport.PageResizer = function()
 {
 };
 
@@ skipping 369 matching lines @@
     ["640 Kbps (3G)", 640 * 1024 / 8],
     ["1 Mbps", 1024 * 1024 / 8],
     ["2 Mbps (802.11b)", 2048 * 1024 / 8],
     ["No throttling", WebInspector.OverridesSupport._networkThroughputUnlimitedValue]
 ];
 
 WebInspector.OverridesSupport.prototype = {
     /**
      * @return {boolean}
      */
+    canEmulate: function()
+    {
+        return !!this._target && !this._target.isMobile();
+    },
+
+    /**
+     * @return {boolean}
+     */
+    emulationEnabled: function()
+    {
+        return this.canEmulate() && this.settings._emulationEnabled.get();
+    },
+
+    /**
+     * @param {boolean} enabled
+     */
+    setEmulationEnabled: function(enabled)
+    {
+        if (this.canEmulate()) {
+            this.settings._emulationEnabled.set(enabled);
+            this.dispatchEventToListeners(WebInspector.OverridesSupport.Events.EmulationStateChanged);
+        }
+    },
+
+    /**
+     * @return {boolean}
+     */
     responsiveDesignAvailable: function()
     {
         return this._responsiveDesignAvailable;
     },
 
     /**
      * @param {?WebInspector.OverridesSupport.PageResizer} pageResizer
      */
     setPageResizer: function(pageResizer)
     {
@@ skipping 77 matching lines @@
 
     applyInitialOverrides: function()
     {
         if (!this._target) {
             this._applyInitialOverridesOnTargetAdded = true;
             return;
         }
 
         this._initialized = true;
 
-        this.settings.emulationEnabled.addChangeListener(this._userAgentChanged, this);
+        this.settings._emulationEnabled.addChangeListener(this._userAgentChanged, this);
         this.settings.userAgent.addChangeListener(this._userAgentChanged, this);
 
-        this.settings.emulationEnabled.addChangeListener(this._deviceMetricsChanged, this);
+        this.settings._emulationEnabled.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.emulationEnabled.addChangeListener(this._geolocationPositionChanged, 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._emulationEnabled.addChangeListener(this._deviceOrientationChanged, this);
         this.settings.overrideDeviceOrientation.addChangeListener(this._deviceOrientationChanged, this);
         this.settings.deviceOrientationOverride.addChangeListener(this._deviceOrientationChanged, this);
 
-        this.settings.emulationEnabled.addChangeListener(this._emulateTouchEventsChanged, this);
+        this.settings._emulationEnabled.addChangeListener(this._emulateTouchEventsChanged, this);
         this.settings.emulateTouch.addChangeListener(this._emulateTouchEventsChanged, this);
 
-        this.settings.emulationEnabled.addChangeListener(this._cssMediaChanged, this);
+        this.settings._emulationEnabled.addChangeListener(this._cssMediaChanged, this);
         this.settings.overrideCSSMedia.addChangeListener(this._cssMediaChanged, this);
         this.settings.emulatedCSSMedia.addChangeListener(this._cssMediaChanged, this);
 
         if (WebInspector.experimentsSettings.networkConditions.isEnabled()) {
-            this.settings.emulationEnabled.addChangeListener(this._networkConditionsChanged, this);
+            this.settings._emulationEnabled.addChangeListener(this._networkConditionsChanged, this);
             this.settings.networkConditionsThroughput.addChangeListener(this._networkConditionsChanged, this);
         }
 
         WebInspector.settings.showMetricsRulers.addChangeListener(this._showRulersChanged, this);
         this._showRulersChanged();
 
-        if (!this.settings.emulationEnabled.get())
+        if (!this.emulationEnabled())
             return;
 
         if (this.settings.overrideDeviceOrientation.get())
             this._deviceOrientationChanged();
 
         if (this.settings.overrideGeolocation.get())
             this._geolocationPositionChanged();
 
         if (this.settings.emulateTouch.get())
             this._emulateTouchEventsChanged();
 
         if (this.settings.overrideCSSMedia.get())
             this._cssMediaChanged();
 
         this._deviceMetricsChanged();
 
         this._userAgentChanged();
 
         if (WebInspector.experimentsSettings.networkConditions.isEnabled() && this.networkThroughputIsLimited())
             this._networkConditionsChanged();
     },
 
     _userAgentChanged: function()
     {
         if (this._userAgentChangedListenerMuted)
             return;
-        var userAgent = this.settings.emulationEnabled.get() ? this.settings.userAgent.get() : "";
+        var userAgent = this.emulationEnabled() ? this.settings.userAgent.get() : "";
         NetworkAgent.setUserAgentOverride(userAgent);
         if (this._userAgent !== userAgent)
             this._updateUserAgentWarningMessage(WebInspector.UIString("You might need to reload the page for proper user agent spoofing and viewport rendering."));
         this._userAgent = userAgent;
-        this.maybeHasActiveOverridesChanged();
     },
 
     _onPageResizerAvailableSizeChanged: function()
     {
         if (this._initialized)
             this._deviceMetricsChanged();
     },
 
     _onPageResizerResizeRequested: function(event)
     {
         if (typeof event.data.width !== "undefined") {
             var width = /** @type {number} */ (event.data.width);
             if (width !== this.settings.deviceWidth.get())
                 this.settings.deviceWidth.set(width);
         }
         if (typeof event.data.height !== "undefined") {
             var height = /** @type {number} */ (event.data.height);
             if (height !== this.settings.deviceHeight.get())
                 this.settings.deviceHeight.set(height);
         }
     },
 
     _deviceMetricsChanged: function()
     {
         this._showRulersChanged();
 
         if (this._deviceMetricsChangedListenerMuted)
             return;
 
-        if (!this.settings.emulationEnabled.get()) {
+        if (!this.emulationEnabled()) {
             this._deviceMetricsThrottler.schedule(clearDeviceMetricsOverride.bind(this));
             if (this._pageResizer)
                 this._pageResizer.update(0, 0, 0);
             return;
         }
 
         var dipWidth = this.settings.deviceWidth.get();
         var dipHeight = this.settings.deviceHeight.get();
 
-        // 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.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 {
@@ skipping 32 matching lines @@
          */
         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.settings.emulationEnabled.get() && this.settings.emulateViewport.get();
+            var viewportEnabled = this.emulationEnabled() && this.settings.emulateViewport.get();
             if (this._emulateViewportEnabled !== viewportEnabled)
                 this._updateDeviceMetricsWarningMessage(WebInspector.UIString("You might need to reload the page for proper user agent spoofing and viewport rendering."));
             this._emulateViewportEnabled = viewportEnabled;
             this._deviceMetricsOverrideAppliedForTest();
-            this.maybeHasActiveOverridesChanged();
             finishCallback();
         }
     },
 
     _deviceMetricsOverrideAppliedForTest: function()
     {
         // Used for sniffing in tests.
     },
 
     _geolocationPositionChanged: function()
     {
-        if (!this.settings.emulationEnabled.get() || !this.settings.overrideGeolocation.get()) {
+        if (!this.emulationEnabled() || !this.settings.overrideGeolocation.get()) {
             GeolocationAgent.clearGeolocationOverride();
             return;
         }
         var geolocation = WebInspector.OverridesSupport.GeolocationPosition.parseSetting(this.settings.geolocationOverride.get());
         if (geolocation.error)
             GeolocationAgent.setGeolocationOverride();
         else
             GeolocationAgent.setGeolocationOverride(geolocation.latitude, geolocation.longitude, 150);
-        this.maybeHasActiveOverridesChanged();
     },
 
     _deviceOrientationChanged: function()
     {
-        if (!this.settings.emulationEnabled.get() || !this.settings.overrideDeviceOrientation.get()) {
+        if (!this.emulationEnabled() || !this.settings.overrideDeviceOrientation.get()) {
             PageAgent.clearDeviceOrientationOverride();
             return;
         }
 
         var deviceOrientation = WebInspector.OverridesSupport.DeviceOrientation.parseSetting(this.settings.deviceOrientationOverride.get());
         PageAgent.setDeviceOrientationOverride(deviceOrientation.alpha, deviceOrientation.beta, deviceOrientation.gamma);
-        this.maybeHasActiveOverridesChanged();
     },
 
     _emulateTouchEventsChanged: function()
     {
-        var emulateTouch = this.settings.emulationEnabled.get() && this.settings.emulateTouch.get();
+        var emulateTouch = this.emulationEnabled() && this.settings.emulateTouch.get();
         var targets = WebInspector.targetManager.targets();
         for (var i = 0; i < targets.length; ++i)
             targets[i].domModel.emulateTouchEventObjects(emulateTouch);
-        this.maybeHasActiveOverridesChanged();
     },
 
     _cssMediaChanged: function()
     {
-        var enabled = !this.isInspectingDevice() && this.settings.emulationEnabled.get() && this.settings.overrideCSSMedia.get();
+        var enabled = this.emulationEnabled() && this.settings.overrideCSSMedia.get();
         PageAgent.setEmulatedMedia(enabled ? this.settings.emulatedCSSMedia.get() : "");
         var targets = WebInspector.targetManager.targets();
         for (var i = 0; i < targets.length; ++i)
             targets[i].cssModel.mediaQueryResultChanged();
-        this.maybeHasActiveOverridesChanged();
     },
 
     _networkConditionsChanged: function()
     {
-        if (!this.settings.emulationEnabled.get() || !this.networkThroughputIsLimited()) {
+        if (!this.emulationEnabled() || !this.networkThroughputIsLimited()) {
             NetworkAgent.emulateNetworkConditions(false, 0, 0, 0);
         } else {
             var throughput = this.settings.networkConditionsThroughput.get();
             var offline = !throughput;
             NetworkAgent.emulateNetworkConditions(offline, 0, throughput, throughput);
         }
-        this.maybeHasActiveOverridesChanged();
     },
 
     /**
      * @return {boolean}
      */
     showMetricsRulers: function()
     {
-        var rulersInPageResizer = this._pageResizer && this.settings.emulationEnabled.get();
+        var rulersInPageResizer = this._pageResizer && this.emulationEnabled();
         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.emulationEnabled.get();
-        if (this._hasActiveOverrides !== hasActiveOverrides) {
-            this._hasActiveOverrides = hasActiveOverrides;
-            this.dispatchEventToListeners(WebInspector.OverridesSupport.Events.HasActiveOverridesChanged);
-        }
-    },
-
     _onMainFrameNavigated: function()
     {
         if (this._initialized)
             this._deviceMetricsChanged();
         this._updateUserAgentWarningMessage("");
         this._updateDeviceMetricsWarningMessage("");
     },
 
     /**
      * @param {string} warningMessage
@@ skipping 32 matching lines @@
      * @param {!WebInspector.Target} target
      */
     targetAdded: function(target)
     {
         // FIXME: adapt this to multiple targets.
         if (this._target)
             return;
         this._target = target;
 
         this.settings = {};
-        this.settings.emulationEnabled = WebInspector.settings.createSetting("emulationEnabled", false);
+        this.settings._emulationEnabled = WebInspector.settings.createSetting("emulationEnabled", false);
 
         this.settings.userAgent = WebInspector.settings.createSetting("userAgent", "");
 
         this.settings.deviceWidth = WebInspector.settings.createSetting("deviceWidth", 0);
         this.settings.deviceHeight = WebInspector.settings.createSetting("deviceHeight", 0);
         this.settings.deviceScaleFactor = WebInspector.settings.createSetting("deviceScaleFactor", 0);
         this.settings.deviceTextAutosizing = WebInspector.settings.createSetting("deviceTextAutosizing", true);
         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.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);
         this.settings.emulatedCSSMedia = WebInspector.settings.createSetting("emulatedCSSMedia", "print");
 
         this.settings.networkConditionsThroughput = WebInspector.settings.createSetting("networkConditionsThroughput", WebInspector.OverridesSupport._networkThroughputUnlimitedValue);
 
-        this.maybeHasActiveOverridesChanged();
-
         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;
     },
 
     /**
      * @return {boolean}
      */
     networkThroughputIsLimited: function()
     {
         return this.settings.networkConditionsThroughput.get() !== WebInspector.OverridesSupport._networkThroughputUnlimitedValue;
     },
 
     /**
      * 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.emulationEnabled.get())
+        if (!this.emulationEnabled())
             return 1;
         var deviceScaleFactor = this.settings.deviceScaleFactor.get();
 
         if (!width || !height || !deviceScaleFactor)
             return 1;
 
         var minWidth = Math.min(width, height) / deviceScaleFactor;
 
         var kMinFSM = 1.05;
         var kWidthForMinFSM = 320;
@@ skipping 10 matching lines @@
         return ratio * (kMaxFSM - kMinFSM) + kMinFSM;
     },
 
     /**
      * @param {!Document} document
      * @return {!Element}
      */
     createDeviceSelect: function(document)
     {
         var deviceSelectElement = document.createElement("select");
-        deviceSelectElement.disabled = WebInspector.overridesSupport.isInspectingDevice();
 
         var selectDeviceOption = new Option(WebInspector.UIString("<Select model>"), WebInspector.UIString("<Select model>"));
         selectDeviceOption.device = new WebInspector.OverridesSupport.Device("", "");
         deviceSelectElement.add(selectDeviceOption);
 
         addGroup(WebInspector.UIString("Devices"), WebInspector.OverridesSupport._phones.concat(WebInspector.OverridesSupport._tablets));
         addGroup(WebInspector.UIString("Notebooks"), WebInspector.OverridesSupport._notebooks);
 
         /**
          * @param {string} name
@@ skipping 104 matching lines @@
     },
 
     __proto__: WebInspector.Object.prototype
 }
 
 
 /**
  * @type {!WebInspector.OverridesSupport}
  */
 WebInspector.overridesSupport;