cc: Use SkMScalar instead of doubles everywhere in cc

cc/base/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 "cc/base/math_util.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 90 matching lines @@
   (*num_vertices_in_clipped_quad)++;
 }
 
 gfx::Rect MathUtil::MapClippedRect(const gfx::Transform& transform,
                                    gfx::Rect src_rect) {
   return gfx::ToEnclosingRect(MapClippedRect(transform, gfx::RectF(src_rect)));
 }
 
 gfx::RectF MathUtil::MapClippedRect(const gfx::Transform& transform,
                                     const gfx::RectF& src_rect) {
-  if (transform.IsIdentityOrTranslation())
+  if (transform.IsIdentityOrTranslation()) {
     return src_rect +
-           gfx::Vector2dF(
-               static_cast<float>(transform.matrix().getDouble(0, 3)),
-               static_cast<float>(transform.matrix().getDouble(1, 3)));
+           gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),

[danakj, 2013/09/11 18:53:46]

can probably use getFloat() now? (thanks for doing that)

[enne (OOO), 2013/09/11 19:58:30]

For some future version of now? I'll land this as-is and fix up later when this
eventually lands and rolls.

[danakj, 2013/09/11 19:59:40]

Ya sorry I figured the skia folks would have committed it by now.

+                          SkMScalarToFloat(transform.matrix().get(1, 3)));
+  }
 
   // Apply the transform, but retain the result in homogeneous coordinates.
 
-  double quad[4 * 2];  // input: 4 x 2D points
+  SkMScalar quad[4 * 2];  // input: 4 x 2D points
   quad[0] = src_rect.x();
   quad[1] = src_rect.y();
   quad[2] = src_rect.right();
   quad[3] = src_rect.y();
   quad[4] = src_rect.right();
   quad[5] = src_rect.bottom();
   quad[6] = src_rect.x();
   quad[7] = src_rect.bottom();
 
-  double result[4 * 4];  // output: 4 x 4D homogeneous points
+  SkMScalar result[4 * 4];  // output: 4 x 4D homogeneous points
   transform.matrix().map2(quad, 4, result);
 
   HomogeneousCoordinate hc0(result[0], result[1], result[2], result[3]);
   HomogeneousCoordinate hc1(result[4], result[5], result[6], result[7]);
   HomogeneousCoordinate hc2(result[8], result[9], result[10], result[11]);
   HomogeneousCoordinate hc3(result[12], result[13], result[14], result[15]);
   return ComputeEnclosingClippedRect(hc0, hc1, hc2, hc3);
 }
 
 gfx::RectF MathUtil::ProjectClippedRect(const gfx::Transform& transform,
                                         const gfx::RectF& src_rect) {
   if (transform.IsIdentityOrTranslation()) {
     return src_rect +
-           gfx::Vector2dF(
-               static_cast<float>(transform.matrix().getDouble(0, 3)),
-               static_cast<float>(transform.matrix().getDouble(1, 3)));
+           gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
+                          SkMScalarToFloat(transform.matrix().get(1, 3)));
   }
 
   // Perform the projection, but retain the result in homogeneous coordinates.
   gfx::QuadF q = gfx::QuadF(src_rect);
   HomogeneousCoordinate h1 = ProjectHomogeneousPoint(transform, q.p1());
   HomogeneousCoordinate h2 = ProjectHomogeneousPoint(transform, q.p2());
   HomogeneousCoordinate h3 = ProjectHomogeneousPoint(transform, q.p3());
   HomogeneousCoordinate h4 = ProjectHomogeneousPoint(transform, q.p4());
 
   return ComputeEnclosingClippedRect(h1, h2, h3, h4);
@@ skipping 167 matching lines @@
   return gfx::RectF(gfx::PointF(xmin, ymin),
                     gfx::SizeF(xmax - xmin, ymax - ymin));
 }
 
 gfx::QuadF MathUtil::MapQuad(const gfx::Transform& transform,
                              const gfx::QuadF& q,
                              bool* clipped) {
   if (transform.IsIdentityOrTranslation()) {
     gfx::QuadF mapped_quad(q);
     mapped_quad +=
-        gfx::Vector2dF(static_cast<float>(transform.matrix().getDouble(0, 3)),
-                       static_cast<float>(transform.matrix().getDouble(1, 3)));
+        gfx::Vector2dF(SkMScalarToFloat(transform.matrix().get(0, 3)),
+                       SkMScalarToFloat(transform.matrix().get(1, 3)));
     *clipped = false;
     return mapped_quad;
   }
 
   HomogeneousCoordinate h1 =
       MapHomogeneousPoint(transform, gfx::Point3F(q.p1()));
   HomogeneousCoordinate h2 =
       MapHomogeneousPoint(transform, gfx::Point3F(q.p2()));
   HomogeneousCoordinate h3 =
       MapHomogeneousPoint(transform, gfx::Point3F(q.p3()));
@@ skipping 114 matching lines @@
       scale_inner_rect.origin() - scale_outer_rect.origin();
   gfx::Vector2dF bottom_right_diff =
       scale_inner_rect.bottom_right() - scale_outer_rect.bottom_right();
   output_inner_rect.Inset(top_left_diff.x() / scale_rect_to_input_scale_x,
                           top_left_diff.y() / scale_rect_to_input_scale_y,
                           -bottom_right_diff.x() / scale_rect_to_input_scale_x,
                           -bottom_right_diff.y() / scale_rect_to_input_scale_y);
   return output_inner_rect;
 }
 
-static inline float ScaleOnAxis(double a, double b, double c) {
+static inline SkMScalar ScaleOnAxis(SkMScalar a, SkMScalar b, SkMScalar c) {

[danakj, 2013/09/11 18:53:46]

here we're multiplying stuff just to take the sqrt, it'd be nice to not throw
away bits. it reminds me of
https://code.google.com/p/chromium/codesearch#chromium/src/ui/gfx/vector2d.cc...

Do you think it's alright to keep the arguments as doubles (or cast them to
double when we multiply them)? Or do you think it's really not worth it?

[enne (OOO), 2013/09/11 19:58:30]

Ok, sure.  I'll buy your argument that the sqrt should be done as a double.

   return std::sqrt(a * a + b * b + c * c);
 }
 
 gfx::Vector2dF MathUtil::ComputeTransform2dScaleComponents(
     const gfx::Transform& transform,
     float fallback_value) {
   if (transform.HasPerspective())
     return gfx::Vector2dF(fallback_value, fallback_value);
-  float x_scale = ScaleOnAxis(transform.matrix().getDouble(0, 0),
-                              transform.matrix().getDouble(1, 0),
-                              transform.matrix().getDouble(2, 0));
-  float y_scale = ScaleOnAxis(transform.matrix().getDouble(0, 1),
-                              transform.matrix().getDouble(1, 1),
-                              transform.matrix().getDouble(2, 1));
-  return gfx::Vector2dF(x_scale, y_scale);
+  SkMScalar x_scale = ScaleOnAxis(transform.matrix().get(0, 0),
+                                  transform.matrix().get(1, 0),
+                                  transform.matrix().get(2, 0));
+  SkMScalar y_scale = ScaleOnAxis(transform.matrix().get(0, 1),
+                                  transform.matrix().get(1, 1),
+                                  transform.matrix().get(2, 1));
+  return gfx::Vector2dF(SkMScalarToFloat(x_scale), SkMScalarToFloat(y_scale));
 }
 
 float MathUtil::SmallestAngleBetweenVectors(gfx::Vector2dF v1,
                                             gfx::Vector2dF v2) {
   double dot_product = gfx::DotProduct(v1, v2) / v1.Length() / v2.Length();
   // Clamp to compensate for rounding errors.
   dot_product = std::max(-1.0, std::min(1.0, dot_product));
   return static_cast<float>(Rad2Deg(std::acos(dot_product)));
 }
 
@@ skipping 92 matching lines @@
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<double>::max())));
 }
 
 scoped_ptr<base::Value> MathUtil::AsValueSafely(float value) {
   return scoped_ptr<base::Value>(base::Value::CreateDoubleValue(
       std::min(value, std::numeric_limits<float>::max())));
 }
 
 }  // namespace cc