Type conversion fixes, ui/gfx/ edition.

ui/gfx/transform_util.cc

 // Copyright (c) 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 "ui/gfx/transform_util.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/logging.h"
@@ skipping 89 matching lines @@
 
   return true;
 }
 
 // Returns false if the matrix cannot be normalized.
 bool Normalize(SkMatrix44& m) {
   if (m.get(3, 3) == 0.0)
     // Cannot normalize.
     return false;
 
-  SkMScalar scale = 1.0 / m.get(3, 3);
+  SkMScalar scale = SK_MScalar1 / m.get(3, 3);
   for (int i = 0; i < 4; i++)
     for (int j = 0; j < 4; j++)
       m.set(i, j, m.get(i, j) * scale);
 
   return true;
 }
 
 SkMatrix44 BuildPerspectiveMatrix(const DecomposedTransform& decomp) {
   SkMatrix44 matrix(SkMatrix44::kIdentity_Constructor);
 
@@ skipping 12 matching lines @@
 }
 
 SkMatrix44 BuildSnappedTranslationMatrix(DecomposedTransform decomp) {
   decomp.translate[0] = Round(decomp.translate[0]);
   decomp.translate[1] = Round(decomp.translate[1]);
   decomp.translate[2] = Round(decomp.translate[2]);
   return BuildTranslationMatrix(decomp);
 }
 
 SkMatrix44 BuildRotationMatrix(const DecomposedTransform& decomp) {
-  double x = decomp.quaternion[0];
-  double y = decomp.quaternion[1];
-  double z = decomp.quaternion[2];
-  double w = decomp.quaternion[3];
+  SkMScalar x = decomp.quaternion[0];
+  SkMScalar y = decomp.quaternion[1];
+  SkMScalar z = decomp.quaternion[2];
+  SkMScalar w = decomp.quaternion[3];
+  SkMScalar two = SkFloatToMScalar(2.0f);
 
   SkMatrix44 matrix(SkMatrix44::kUninitialized_Constructor);
 
   // Implicitly calls matrix.setIdentity()
-  matrix.set3x3(1.0 - 2.0 * (y * y + z * z),
-                2.0 * (x * y + z * w),
-                2.0 * (x * z - y * w),
-                2.0 * (x * y - z * w),
-                1.0 - 2.0 * (x * x + z * z),
-                2.0 * (y * z + x * w),
-                2.0 * (x * z + y * w),
-                2.0 * (y * z - x * w),
-                1.0 - 2.0 * (x * x + y * y));
+  matrix.set3x3(SK_MScalar1 - two * (y * y + z * z),

[danakj, 2014/10/18 18:40:06]

i think you should downcast to float after the computation is done for each of
these components and keep the x/y/z/w as doubles. this is definitely a change of
behaviour otherwise

[Peter Kasting, 2014/10/20 23:38:56]

Done.  It might be nice to have a test that would fail on the earlier version of
my change (but I don't know that I can write one myself).

[danakj, 2014/10/23 15:35:44]

I agree, tho I'm not sure either :) +awoloszyn FYI

+                two * (x * y + z * w),
+                two * (x * z - y * w),
+                two * (x * y - z * w),
+                SK_MScalar1 - two * (x * x + z * z),
+                two * (y * z + x * w),
+                two * (x * z + y * w),
+                two * (y * z - x * w),
+                SK_MScalar1 - two * (x * x + y * y));
   return matrix;
 }
 
 SkMatrix44 BuildSnappedRotationMatrix(const DecomposedTransform& decomp) {
   // Create snapped rotation.
   SkMatrix44 rotation_matrix = BuildRotationMatrix(decomp);
   for (int i = 0; i < 3; ++i) {
     for (int j = 0; j < 3; ++j) {
       SkMScalar value = rotation_matrix.get(i, j);
       // Snap values to -1, 0 or 1.
@@ skipping 196 matching lines @@
     decomp->translate[i] = matrix.get(i, 3);
 
   SkMScalar row[3][3];
   for (int i = 0; i < 3; i++)
     for (int j = 0; j < 3; ++j)
       row[i][j] = matrix.get(j, i);
 
   // Compute X scale factor and normalize first row.
   decomp->scale[0] = Length3(row[0]);
   if (decomp->scale[0] != 0.0)
-    Scale3(row[0], 1.0 / decomp->scale[0]);
+    Scale3(row[0], SK_MScalar1 / decomp->scale[0]);
 
   // Compute XY shear factor and make 2nd row orthogonal to 1st.
   decomp->skew[0] = Dot<3>(row[0], row[1]);
   Combine<3>(row[1], row[1], row[0], 1.0, -decomp->skew[0]);
 
   // Now, compute Y scale and normalize 2nd row.
   decomp->scale[1] = Length3(row[1]);
   if (decomp->scale[1] != 0.0)
-    Scale3(row[1], 1.0 / decomp->scale[1]);
+    Scale3(row[1], SK_MScalar1 / decomp->scale[1]);
 
   decomp->skew[0] /= decomp->scale[1];
 
   // Compute XZ and YZ shears, orthogonalize 3rd row
   decomp->skew[1] = Dot<3>(row[0], row[2]);
   Combine<3>(row[2], row[2], row[0], 1.0, -decomp->skew[1]);
   decomp->skew[2] = Dot<3>(row[1], row[2]);
   Combine<3>(row[2], row[2], row[1], 1.0, -decomp->skew[2]);
 
   // Next, get Z scale and normalize 3rd row.
   decomp->scale[2] = Length3(row[2]);
   if (decomp->scale[2] != 0.0)
-    Scale3(row[2], 1.0 / decomp->scale[2]);
+    Scale3(row[2], SK_MScalar1 / decomp->scale[2]);
 
   decomp->skew[1] /= decomp->scale[2];
   decomp->skew[2] /= decomp->scale[2];
 
   // At this point, the matrix (in rows) is orthonormal.
   // Check for a coordinate system flip.  If the determinant
   // is -1, then negate the matrix and the scaling factors.
   SkMScalar pdum3[3];
   Cross3(pdum3, row[1], row[2]);
   if (Dot<3>(row[0], pdum3) < 0) {
     for (int i = 0; i < 3; i++) {
       decomp->scale[i] *= -1.0;
       for (int j = 0; j < 3; ++j)
         row[i][j] *= -1.0;
     }
   }
 
-  decomp->quaternion[0] =
-      0.5 * std::sqrt(std::max(1.0 + row[0][0] - row[1][1] - row[2][2], 0.0));
-  decomp->quaternion[1] =
-      0.5 * std::sqrt(std::max(1.0 - row[0][0] + row[1][1] - row[2][2], 0.0));
-  decomp->quaternion[2] =
-      0.5 * std::sqrt(std::max(1.0 - row[0][0] - row[1][1] + row[2][2], 0.0));
-  decomp->quaternion[3] =
-      0.5 * std::sqrt(std::max(1.0 + row[0][0] + row[1][1] + row[2][2], 0.0));
+  SkMScalar half = SkFloatToMScalar(0.5f);
+  double row00 = SkMScalarToDouble(row[0][0]);
+  double row11 = SkMScalarToDouble(row[1][1]);
+  double row22 = SkMScalarToDouble(row[2][2]);
+  decomp->quaternion[0] = half *
+      std::sqrt(SkDoubleToMScalar(std::max(1.0 + row00 - row11 - row22, 0.0)));

[danakj, 2014/10/18 18:40:06]

do the double to mscalar after taking the sqrt

[Peter Kasting, 2014/10/20 23:38:56]

Done.

+  decomp->quaternion[1] = half *
+      std::sqrt(SkDoubleToMScalar(std::max(1.0 - row00 + row11 - row22, 0.0)));
+  decomp->quaternion[2] = half *
+      std::sqrt(SkDoubleToMScalar(std::max(1.0 - row00 - row11 + row22, 0.0)));
+  decomp->quaternion[3] = half *
+      std::sqrt(SkDoubleToMScalar(std::max(1.0 + row00 + row11 + row22, 0.0)));
 
   if (row[2][1] > row[1][2])
       decomp->quaternion[0] = -decomp->quaternion[0];
   if (row[0][2] > row[2][0])
       decomp->quaternion[1] = -decomp->quaternion[1];
   if (row[1][0] > row[0][1])
       decomp->quaternion[2] = -decomp->quaternion[2];
 
   return true;
 }
@@ skipping 58 matching lines @@
       perspective[1],
       perspective[2],
       perspective[3],
       quaternion[0],
       quaternion[1],
       quaternion[2],
       quaternion[3]);
 }
 
 }  // namespace ui