cc: Create a Region class that wraps SkRegion, to replace use of WebCore::Region.

cc/math_util.cc

 // Copyright 2012 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.
 
 #include "config.h"
 
 #include "cc/math_util.h"
 
 #include <cmath>
 #include <limits>
 
+#include "cc/geometry.h"

[danakj, 2012/11/05 21:13:30]

not needed now, will remove.

 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/rect_f.h"
 #include "ui/gfx/vector2d_f.h"
 #include <public/WebTransformationMatrix.h>
 
 using WebKit::WebTransformationMatrix;
 
 namespace cc {
 
+const double MathUtil::PI_DOUBLE = 3.14159265358979323846;
+const float MathUtil::PI_FLOAT = 3.14159265358979323846f;
+
 static HomogeneousCoordinate projectHomogeneousPoint(const WebTransformationMatrix& transform, const gfx::PointF& p)
 {
     // In this case, the layer we are trying to project onto is perpendicular to ray
     // (point p and z-axis direction) that we are trying to project. This happens when the
     // layer is rotated so that it is infinitesimally thin, or when it is co-planar with
     // the camera origin -- i.e. when the layer is invisible anyway.
     if (!transform.m33())
         return HomogeneousCoordinate(0, 0, 0, 1);
 
     double x = p.x();
@@ skipping 340 matching lines @@
 
 gfx::Vector2dF MathUtil::computeTransform2dScaleComponents(const WebTransformationMatrix& transform)
 {
     if (transform.hasPerspective())
         return gfx::Vector2dF(1, 1);
     float xScale = scaleOnAxis(transform.m11(), transform.m12(), transform.m13());
     float yScale = scaleOnAxis(transform.m21(), transform.m22(), transform.m23());
     return gfx::Vector2dF(xScale, yScale);
 }
 
-static inline double rad2deg(double r)
-{
-  double pi = 3.14159265358979323846;
-  return r * 180.0 / pi;
-}
-
 float MathUtil::smallestAngleBetweenVectors(gfx::Vector2dF v1, gfx::Vector2dF v2)
 {
     double dotProduct = gfx::DotProduct(v1, v2) / v1.Length() / v2.Length();
     // Clamp to compensate for rounding errors.
     dotProduct = std::max(-1.0, std::min(1.0, dotProduct));
-    return static_cast<float>(rad2deg(std::acos(dotProduct)));
+    return static_cast<float>(Rad2Deg(std::acos(dotProduct)));
 }
 
 gfx::Vector2dF MathUtil::projectVector(gfx::Vector2dF source, gfx::Vector2dF destination)
 {
     float projectedLength = gfx::DotProduct(source, destination) / destination.LengthSquared();
     return gfx::Vector2dF(projectedLength * destination.x(), projectedLength * destination.y());
 }
 
 }  // namespace cc