DevTools: move from Common module - Geometry and CSSShadowModel

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

 // Copyright 2015 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.
 /**
  * @implements {SDK.TargetManager.Observer}
  * @unrestricted
  */
 Emulation.DeviceModeModel = class {
   /**
    * @param {function()} updateCallback
    */
   constructor(updateCallback) {
     this._updateCallback = updateCallback;
-    this._screenRect = new Common.Rect(0, 0, 1, 1);
-    this._visiblePageRect = new Common.Rect(0, 0, 1, 1);
-    this._availableSize = new Size(1, 1);
-    this._preferredSize = new Size(1, 1);
+    this._screenRect = new UI.Rect(0, 0, 1, 1);
+    this._visiblePageRect = new UI.Rect(0, 0, 1, 1);
+    this._availableSize = new UI.Size(1, 1);
+    this._preferredSize = new UI.Size(1, 1);
     this._initialized = false;
     this._deviceMetricsThrottler = new Common.Throttler(0);
-    this._appliedDeviceSize = new Size(1, 1);
+    this._appliedDeviceSize = new UI.Size(1, 1);
     this._appliedDeviceScaleFactor = window.devicePixelRatio;
     this._appliedUserAgentType = Emulation.DeviceModeModel.UA.Desktop;
 
     this._scaleSetting = Common.settings.createSetting('emulation.deviceScale', 1);
     // We've used to allow zero before.
     if (!this._scaleSetting.get())
       this._scaleSetting.set(1);
     this._scaleSetting.addChangeListener(this._scaleSettingChanged, this);
 
     this._widthSetting = Common.settings.createSetting('emulation.deviceWidth', 400);
@@ skipping 49 matching lines @@
    * @param {string} value
    * @return {boolean}
    */
   static deviceScaleFactorValidator(value) {
     if (!value || (/^[\d]+(\.\d+)?|\.\d+$/.test(value) && value >= 0 && value <= 10))
       return true;
     return false;
   }
 
   /**
-   * @param {!Size} availableSize
-   * @param {!Size} preferredSize
+   * @param {!UI.Size} availableSize
+   * @param {!UI.Size} preferredSize
    */
   setAvailableSize(availableSize, preferredSize) {
     this._availableSize = availableSize;
     this._preferredSize = preferredSize;
     this._initialized = true;
     this._calculateAndEmulate(false);
   }
 
   /**
    * @param {!Emulation.DeviceModeModel.Type} type
@@ skipping 101 matching lines @@
 
   /**
    * @return {string}
    */
   outlineImage() {
     return (this._device && this._mode && this._deviceOutlineSetting.get()) ? this._device.outlineImage(this._mode) :
                                                                               '';
   }
 
   /**
-   * @return {!Common.Rect}
+   * @return {!UI.Rect}
    */
   outlineRect() {
     return this._outlineRect;
   }
 
   /**
-   * @return {!Common.Rect}
+   * @return {!UI.Rect}
    */
   screenRect() {
     return this._screenRect;
   }
 
   /**
-   * @return {!Common.Rect}
+   * @return {!UI.Rect}
    */
   visiblePageRect() {
     return this._visiblePageRect;
   }
 
   /**
    * @return {number}
    */
   scale() {
     return this._scale;
   }
 
   /**
    * @return {number}
    */
   fitScale() {
     return this._fitScale;
   }
 
   /**
-   * @return {!Size}
+   * @return {!UI.Size}
    */
   appliedDeviceSize() {
     return this._appliedDeviceSize;
   }
 
   /**
    * @return {number}
    */
   appliedDeviceScaleFactor() {
     return this._appliedDeviceScaleFactor;
@@ skipping 105 matching lines @@
   }
 
   /**
    * @return {number}
    */
   _preferredScaledHeight() {
     return Math.floor(this._preferredSize.height / (this._scaleSetting.get() || 1));
   }
 
   /**
-   * @return {!Insets}
+   * @return {!UI.Insets}
    */
   _currentOutline() {
-    var outline = new Insets(0, 0, 0, 0);
+    var outline = new UI.Insets(0, 0, 0, 0);
     if (this._type !== Emulation.DeviceModeModel.Type.Device)
       return outline;
     var orientation = this._device.orientationByName(this._mode.orientation);
     if (this._deviceOutlineSetting.get())
       outline = orientation.outlineInsets || outline;
     return outline;
   }
 
   /**
-   * @return {!Insets}
+   * @return {!UI.Insets}
    */
   _currentInsets() {
     if (this._type !== Emulation.DeviceModeModel.Type.Device)
-      return new Insets(0, 0, 0, 0);
+      return new UI.Insets(0, 0, 0, 0);
     return this._mode.insets;
   }
 
   /**
    * @param {boolean} resetPageScaleFactor
    */
   _calculateAndEmulate(resetPageScaleFactor) {
     if (!this._target)
       this._onTargetAvailable = this._calculateAndEmulate.bind(this, resetPageScaleFactor);
 
     if (this._type === Emulation.DeviceModeModel.Type.Device) {
       var orientation = this._device.orientationByName(this._mode.orientation);
       var outline = this._currentOutline();
       var insets = this._currentInsets();
       this._fitScale = this._calculateFitScale(orientation.width, orientation.height, outline, insets);
       if (this._device.mobile()) {
         this._appliedUserAgentType =
             this._device.touch() ? Emulation.DeviceModeModel.UA.Mobile : Emulation.DeviceModeModel.UA.MobileNoTouch;
       } else {
         this._appliedUserAgentType =
             this._device.touch() ? Emulation.DeviceModeModel.UA.DesktopTouch : Emulation.DeviceModeModel.UA.Desktop;
       }
       this._applyDeviceMetrics(
-          new Size(orientation.width, orientation.height), insets, outline, this._scaleSetting.get(),
+          new UI.Size(orientation.width, orientation.height), insets, outline, this._scaleSetting.get(),
           this._device.deviceScaleFactor, this._device.mobile(),
           this._mode.orientation === Emulation.EmulatedDevice.Horizontal ? 'landscapePrimary' : 'portraitPrimary',
           resetPageScaleFactor);
       this._applyUserAgent(this._device.userAgent);
       this._applyTouch(this._device.touch(), this._device.mobile());
     } else if (this._type === Emulation.DeviceModeModel.Type.None) {
       this._fitScale = this._calculateFitScale(this._availableSize.width, this._availableSize.height);
       this._appliedUserAgentType = Emulation.DeviceModeModel.UA.Desktop;
       this._applyDeviceMetrics(
-          this._availableSize, new Insets(0, 0, 0, 0), new Insets(0, 0, 0, 0), 1, 0, false, '', resetPageScaleFactor);
+          this._availableSize, new UI.Insets(0, 0, 0, 0), new UI.Insets(0, 0, 0, 0), 1, 0, false, '',
+          resetPageScaleFactor);
       this._applyUserAgent('');
       this._applyTouch(false, false);
     } else if (this._type === Emulation.DeviceModeModel.Type.Responsive) {
       var screenWidth = this._widthSetting.get();
       if (!screenWidth || screenWidth > this._preferredScaledWidth())
         screenWidth = this._preferredScaledWidth();
       var screenHeight = this._heightSetting.get();
       if (!screenHeight || screenHeight > this._preferredScaledHeight())
         screenHeight = this._preferredScaledHeight();
       var mobile = this._uaSetting.get() === Emulation.DeviceModeModel.UA.Mobile ||
           this._uaSetting.get() === Emulation.DeviceModeModel.UA.MobileNoTouch;
       var defaultDeviceScaleFactor = mobile ? Emulation.DeviceModeModel.defaultMobileScaleFactor : 0;
       this._fitScale = this._calculateFitScale(this._widthSetting.get(), this._heightSetting.get());
       this._appliedUserAgentType = this._uaSetting.get();
       this._applyDeviceMetrics(
-          new Size(screenWidth, screenHeight), new Insets(0, 0, 0, 0), new Insets(0, 0, 0, 0), this._scaleSetting.get(),
-          this._deviceScaleFactorSetting.get() || defaultDeviceScaleFactor, mobile,
+          new UI.Size(screenWidth, screenHeight), new UI.Insets(0, 0, 0, 0), new UI.Insets(0, 0, 0, 0),
+          this._scaleSetting.get(), this._deviceScaleFactorSetting.get() || defaultDeviceScaleFactor, mobile,
           screenHeight >= screenWidth ? 'portraitPrimary' : 'landscapePrimary', resetPageScaleFactor);
       this._applyUserAgent(mobile ? Emulation.DeviceModeModel._defaultMobileUserAgent : '');
       this._applyTouch(
           this._uaSetting.get() === Emulation.DeviceModeModel.UA.DesktopTouch ||
               this._uaSetting.get() === Emulation.DeviceModeModel.UA.Mobile,
           this._uaSetting.get() === Emulation.DeviceModeModel.UA.Mobile);
     }
     if (this._target)
       this._target.renderingAgent().setShowViewportSizeOnResize(this._type === Emulation.DeviceModeModel.Type.None);
     this._updateCallback.call(null);
   }
 
   /**
    * @param {number} screenWidth
    * @param {number} screenHeight
-   * @param {!Insets=} outline
-   * @param {!Insets=} insets
+   * @param {!UI.Insets=} outline
+   * @param {!UI.Insets=} insets
    * @return {number}
    */
   _calculateFitScale(screenWidth, screenHeight, outline, insets) {
     var outlineWidth = outline ? outline.left + outline.right : 0;
     var outlineHeight = outline ? outline.top + outline.bottom : 0;
     var insetsWidth = insets ? insets.left + insets.right : 0;
     var insetsHeight = insets ? insets.top + insets.bottom : 0;
     var scale = Math.min(
         screenWidth ? this._preferredSize.width / (screenWidth + outlineWidth) : 1,
         screenHeight ? this._preferredSize.height / (screenHeight + outlineHeight) : 1);
@@ skipping 23 matching lines @@
   }
 
   /**
    * @param {string} userAgent
    */
   _applyUserAgent(userAgent) {
     SDK.multitargetNetworkManager.setUserAgentOverride(userAgent);
   }
 
   /**
-   * @param {!Size} screenSize
-   * @param {!Insets} insets
-   * @param {!Insets} outline
+   * @param {!UI.Size} screenSize
+   * @param {!UI.Insets} insets
+   * @param {!UI.Insets} outline
    * @param {number} scale
    * @param {number} deviceScaleFactor
    * @param {boolean} mobile
    * @param {string} screenOrientation
    * @param {boolean} resetPageScaleFactor
    */
   _applyDeviceMetrics(
       screenSize,
       insets,
       outline,
       scale,
       deviceScaleFactor,
       mobile,
       screenOrientation,
       resetPageScaleFactor) {
     screenSize.width = Math.max(1, Math.floor(screenSize.width));
     screenSize.height = Math.max(1, Math.floor(screenSize.height));
 
     var pageWidth = screenSize.width - insets.left - insets.right;
     var pageHeight = screenSize.height - insets.top - insets.bottom;
 
     var positionX = insets.left;
     var positionY = insets.top;
     var screenOrientationAngle = screenOrientation === 'landscapePrimary' ? 90 : 0;
 
     this._appliedDeviceSize = screenSize;
     this._appliedDeviceScaleFactor = deviceScaleFactor || window.devicePixelRatio;
-    this._screenRect = new Common.Rect(
+    this._screenRect = new UI.Rect(
         Math.max(0, (this._availableSize.width - screenSize.width * scale) / 2), outline.top * scale,
         screenSize.width * scale, screenSize.height * scale);
-    this._outlineRect = new Common.Rect(
+    this._outlineRect = new UI.Rect(
         this._screenRect.left - outline.left * scale, 0, (outline.left + screenSize.width + outline.right) * scale,
         (outline.top + screenSize.height + outline.bottom) * scale);
-    this._visiblePageRect = new Common.Rect(
+    this._visiblePageRect = new UI.Rect(
         positionX * scale, positionY * scale,
         Math.min(pageWidth * scale, this._availableSize.width - this._screenRect.left - positionX * scale),
         Math.min(pageHeight * scale, this._availableSize.height - this._screenRect.top - positionY * scale));
     this._scale = scale;
 
     if (scale === 1 && this._availableSize.width >= screenSize.width &&
         this._availableSize.height >= screenSize.height) {
       // When we have enough space, no page size override is required. This will speed things up and remove lag.
       pageWidth = 0;
       pageHeight = 0;
@@ skipping 76 matching lines @@
 
 Emulation.DeviceModeModel.MinDeviceSize = 50;
 Emulation.DeviceModeModel.MaxDeviceSize = 9999;
 
 
 Emulation.DeviceModeModel._defaultMobileUserAgent =
     'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/%s Mobile Safari/537.36';
 Emulation.DeviceModeModel._defaultMobileUserAgent =
     SDK.MultitargetNetworkManager.patchUserAgentWithChromeVersion(Emulation.DeviceModeModel._defaultMobileUserAgent);
 Emulation.DeviceModeModel.defaultMobileScaleFactor = 2;