DevTools: move from Common module - Geometry and CSSShadowModel

third_party/WebKit/Source/devtools/front_end/layer_viewer/Layers3DView.js

 /*
  * Copyright (C) 2014 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 247 matching lines @@
     }
     var scaleAndRotationMatrix = new WebKitCSSMatrix()
                                      .scale(scale, scale, scale)
                                      .translate(canvasWidth / 2, canvasHeight / 2, 0)
                                      .rotate(rotateX, rotateY, 0)
                                      .scale(viewScale, viewScale, viewScale)
                                      .translate(-baseWidth / 2, -baseHeight / 2, 0);
 
     var bounds;
     for (var i = 0; i < this._rects.length; ++i)
-      bounds = Common.Geometry.boundsForTransformedPoints(scaleAndRotationMatrix, this._rects[i].vertices, bounds);
+      bounds = UI.Geometry.boundsForTransformedPoints(scaleAndRotationMatrix, this._rects[i].vertices, bounds);
 
     this._transformController.clampOffsets(
         (paddingX - bounds.maxX) / window.devicePixelRatio,
         (canvasWidth - paddingX - bounds.minX) / window.devicePixelRatio,
         (paddingY - bounds.maxY) / window.devicePixelRatio,
         (canvasHeight - paddingY - bounds.minY) / window.devicePixelRatio);
     var offsetX = this._transformController.offsetX() * window.devicePixelRatio;
     var offsetY = this._transformController.offsetY() * window.devicePixelRatio;
     // Multiply to translation matrix on the right rather than translate (which would implicitly multiply on the left).
     this._projectionMatrix = new WebKitCSSMatrix().translate(offsetX, offsetY, 0).multiply(scaleAndRotationMatrix);
@@ skipping 820 matching lines @@
    * @param {!CSSMatrix} matrix
    * @param {number} x0
    * @param {number} y0
    * @return {(number|undefined)}
    */
   intersectWithLine(matrix, x0, y0) {
     var i;
     // Vertices of the quad with transform matrix applied
     var points = [];
     for (i = 0; i < 4; ++i) {
-      points[i] = Common.Geometry.multiplyVectorByMatrixAndNormalize(
-          new Common.Geometry.Vector(this.vertices[i * 3], this.vertices[i * 3 + 1], this.vertices[i * 3 + 2]), matrix);
+      points[i] = UI.Geometry.multiplyVectorByMatrixAndNormalize(
+          new UI.Geometry.Vector(this.vertices[i * 3], this.vertices[i * 3 + 1], this.vertices[i * 3 + 2]), matrix);
     }
     // Calculating quad plane normal
-    var normal = Common.Geometry.crossProduct(
-        Common.Geometry.subtract(points[1], points[0]), Common.Geometry.subtract(points[2], points[1]));
+    var normal = UI.Geometry.crossProduct(
+        UI.Geometry.subtract(points[1], points[0]), UI.Geometry.subtract(points[2], points[1]));
     // General form of the equation of the quad plane: A * x + B * y + C * z + D = 0
     var A = normal.x;
     var B = normal.y;
     var C = normal.z;
     var D = -(A * points[0].x + B * points[0].y + C * points[0].z);
     // Finding t from the equation
     var t = -(D + A * x0 + B * y0) / C;
     // Point of the intersection
-    var pt = new Common.Geometry.Vector(x0, y0, t);
+    var pt = new UI.Geometry.Vector(x0, y0, t);
     // Vectors from the intersection point to vertices of the quad
-    var tVects = points.map(Common.Geometry.subtract.bind(null, pt));
+    var tVects = points.map(UI.Geometry.subtract.bind(null, pt));
     // Intersection point lies inside of the polygon if scalar products of normal of the plane and
     // cross products of successive tVects are all nonstrictly above or all nonstrictly below zero
     for (i = 0; i < tVects.length; ++i) {
-      var product = Common.Geometry.scalarProduct(
-          normal, Common.Geometry.crossProduct(tVects[i], tVects[(i + 1) % tVects.length]));
+      var product =
+          UI.Geometry.scalarProduct(normal, UI.Geometry.crossProduct(tVects[i], tVects[(i + 1) % tVects.length]));
       if (product < 0)
         return undefined;
     }
     return t;
   }
 };
 
 
 /**
  * @unrestricted
@@ skipping 35 matching lines @@
    * @return {!Promise}
    */
   update(glContext, scale) {
     this._gl = glContext;
     this.scale = scale;
     return this.snapshot.replay(null, null, scale).then(imageURL => imageURL && UI.loadImage(imageURL)).then(image => {
       this.texture = image && LayerViewer.LayerTextureManager._createTextureForImage(glContext, image);
     });
   }
 };