Fix compilation and ui_unittests with float transforms

This change also cleans up the use of gfx::Transform::get/setDouble
(in favor of get/set) at callsites to prepare for changing SkMScalar
from double to float.

BUG=269817

Originally Committed/Reverted: https://src.chromium.org/viewvc/chrome?view=rev&revision=224725

Review URL: https://chromiumcodereview.appspot.com/23811009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@225130 0039d316-1c4b-4281-b951-d872f2087c98

26 files changed, 426 insertions, 380 deletions

diff --git a/cc/animation/keyframed_animation_curve_unittest.cc b/cc/animation/keyframed_animation_curve_unittest.cc
index 48f511c0..7eb3b1c 100644
--- a/cc/animation/keyframed_animation_curve_unittest.cc
+++ b/cc/animation/keyframed_animation_curve_unittest.cc
@@ -12,8 +12,8 @@
 namespace cc {
 namespace {
 
-void ExpectTranslateX(double translate_x, const gfx::Transform& transform) {
-  EXPECT_FLOAT_EQ(translate_x, transform.matrix().getDouble(0, 3));
+void ExpectTranslateX(SkMScalar translate_x, const gfx::Transform& transform) {
+  EXPECT_FLOAT_EQ(translate_x, transform.matrix().get(0, 3));
 }
 
 void ExpectBrightness(double brightness, const FilterOperations& filter) {
@@ -185,8 +185,8 @@ TEST(KeyframedAnimationCurveTest, RepeatedTransformKeyTimes) {
 
   // There is a discontinuity at 1. Any value between 4 and 6 is valid.
   gfx::Transform value = curve->GetValue(1.f);
-  EXPECT_GE(value.matrix().getDouble(0.f, 3.f), 4);
-  EXPECT_LE(value.matrix().getDouble(0.f, 3.f), 6);
+  EXPECT_GE(value.matrix().get(0, 3), 4.f);
+  EXPECT_LE(value.matrix().get(0, 3), 6.f);
 
   ExpectTranslateX(6.f, curve->GetValue(1.5f));
   ExpectTranslateX(6.f, curve->GetValue(2.f));
diff --git a/cc/animation/transform_operation.cc b/cc/animation/transform_operation.cc
index 93f40f3..a06b533 100644
--- a/cc/animation/transform_operation.cc
+++ b/cc/animation/transform_operation.cc
@@ -12,7 +12,7 @@
 #include "ui/gfx/vector3d_f.h"
 
 namespace {
-const SkMScalar kAngleEpsilon = 1e-4;
+const SkMScalar kAngleEpsilon = 1e-4f;
 }
 
 namespace cc {
diff --git a/cc/base/float_quad_unittest.cc b/cc/base/float_quad_unittest.cc
index 186624e..c2186fd81 100644
--- a/cc/base/float_quad_unittest.cc
+++ b/cc/base/float_quad_unittest.cc
@@ -15,15 +15,15 @@ namespace {
 TEST(FloatQuadTest, IsRectilinearTest) {
   const int kNumRectilinear = 8;
   gfx::Transform rectilinear_trans[kNumRectilinear];
-  rectilinear_trans[1].Rotate(90.0);
-  rectilinear_trans[2].Rotate(180.0);
-  rectilinear_trans[3].Rotate(270.0);
-  rectilinear_trans[4].SkewX(0.00000000001);
-  rectilinear_trans[5].SkewY(0.00000000001);
-  rectilinear_trans[6].Scale(0.00001, 0.00001);
-  rectilinear_trans[6].Rotate(180.0);
-  rectilinear_trans[7].Scale(100000, 100000);
-  rectilinear_trans[7].Rotate(180.0);
+  rectilinear_trans[1].Rotate(90.f);
+  rectilinear_trans[2].Rotate(180.f);
+  rectilinear_trans[3].Rotate(270.f);
+  rectilinear_trans[4].SkewX(0.00000000001f);
+  rectilinear_trans[5].SkewY(0.00000000001f);
+  rectilinear_trans[6].Scale(0.00001f, 0.00001f);
+  rectilinear_trans[6].Rotate(180.f);
+  rectilinear_trans[7].Scale(100000.f, 100000.f);
+  rectilinear_trans[7].Rotate(180.f);
 
   gfx::QuadF original(
       gfx::RectF(0.01010101f, 0.01010101f, 100.01010101f, 100.01010101f));
@@ -38,16 +38,16 @@ TEST(FloatQuadTest, IsRectilinearTest) {
 
   const int kNumNonRectilinear = 10;
   gfx::Transform non_rectilinear_trans[kNumNonRectilinear];
-  non_rectilinear_trans[0].Rotate(359.999);
-  non_rectilinear_trans[1].Rotate(0.0000001);
-  non_rectilinear_trans[2].Rotate(89.999999);
-  non_rectilinear_trans[3].Rotate(90.0000001);
-  non_rectilinear_trans[4].Rotate(179.999999);
-  non_rectilinear_trans[5].Rotate(180.0000001);
-  non_rectilinear_trans[6].Rotate(269.999999);
-  non_rectilinear_trans[7].Rotate(270.0000001);
-  non_rectilinear_trans[8].SkewX(0.00001);
-  non_rectilinear_trans[9].SkewY(0.00001);
+  non_rectilinear_trans[0].Rotate(359.9999f);
+  non_rectilinear_trans[1].Rotate(0.0000001f);
+  non_rectilinear_trans[2].Rotate(89.9999f);
+  non_rectilinear_trans[3].Rotate(90.00001f);
+  non_rectilinear_trans[4].Rotate(179.9999f);
+  non_rectilinear_trans[5].Rotate(180.00001f);
+  non_rectilinear_trans[6].Rotate(269.9999f);
+  non_rectilinear_trans[7].Rotate(270.0001f);
+  non_rectilinear_trans[8].SkewX(0.00001f);
+  non_rectilinear_trans[9].SkewY(0.00001f);
 
   for (int i = 0; i < kNumNonRectilinear; ++i) {
     bool clipped = false;
diff --git a/cc/base/math_util.cc b/cc/base/math_util.cc
index 40b8d11..764c461 100644
--- a/cc/base/math_util.cc
+++ b/cc/base/math_util.cc
@@ -72,13 +72,13 @@ static HomogeneousCoordinate ComputeClippedPointForEdge(
   // w plane when this is called.
   DCHECK(h1.ShouldBeClipped() ^ h2.ShouldBeClipped());
 
-  SkMScalar w = 0.00001;  // or any positive non-zero small epsilon
+  // ...or any positive non-zero small epsilon
+  double w = 0.00001;
+  double t = (w - h1.w()) / (h2.w() - h1.w());
 
-  SkMScalar t = (w - h1.w()) / (h2.w() - h1.w());
-
-  SkMScalar x = (1 - t) * h1.x() + t * h2.x();
-  SkMScalar y = (1 - t) * h1.y() + t * h2.y();
-  SkMScalar z = (1 - t) * h1.z() + t * h2.z();
+  SkMScalar x = SkDoubleToMScalar((1.0 - t) * h1.x() + t * h2.x());
+  SkMScalar y = SkDoubleToMScalar((1.0 - t) * h1.y() + t * h2.y());
+  SkMScalar z = SkDoubleToMScalar((1.0 - t) * h1.z() + t * h2.z());
 
   return HomogeneousCoordinate(x, y, z, w);
 }
diff --git a/cc/base/math_util.h b/cc/base/math_util.h
index 7912f8a..67a9370 100644
--- a/cc/base/math_util.h
+++ b/cc/base/math_util.h
@@ -39,24 +39,24 @@ struct HomogeneousCoordinate {
   bool ShouldBeClipped() const { return w() <= 0.0; }
 
   gfx::PointF CartesianPoint2d() const {
-    if (w() == 1.0)
+    if (w() == SK_MScalar1)
       return gfx::PointF(x(), y());
 
     // For now, because this code is used privately only by MathUtil, it should
     // never be called when w == 0, and we do not yet need to handle that case.
     DCHECK(w());
-    SkMScalar inv_w = 1.0 / w();
+    SkMScalar inv_w = SK_MScalar1 / w();
     return gfx::PointF(x() * inv_w, y() * inv_w);
   }
 
   gfx::Point3F CartesianPoint3d() const {
-    if (w() == 1)
+    if (w() == SK_MScalar1)
       return gfx::Point3F(x(), y(), z());
 
     // For now, because this code is used privately only by MathUtil, it should
     // never be called when w == 0, and we do not yet need to handle that case.
     DCHECK(w());
-    SkMScalar inv_w = 1.0 / w();
+    SkMScalar inv_w = SK_MScalar1 / w();
     return gfx::Point3F(x() * inv_w, y() * inv_w, z() * inv_w);
   }
 
diff --git a/cc/base/math_util_unittest.cc b/cc/base/math_util_unittest.cc
index d62280d..5bcf2ee 100644
--- a/cc/base/math_util_unittest.cc
+++ b/cc/base/math_util_unittest.cc
@@ -22,7 +22,7 @@ TEST(MathUtilTest, ProjectionOfPerpendicularPlane) {
 
   gfx::Transform transform;
   transform.MakeIdentity();
-  transform.matrix().setDouble(2, 2, 0);
+  transform.matrix().set(2, 2, 0);
 
   gfx::RectF rect = gfx::RectF(0, 0, 1, 1);
   gfx::RectF projected_rect = MathUtil::ProjectClippedRect(transform, rect);
diff --git a/cc/layers/delegated_renderer_layer_impl_unittest.cc b/cc/layers/delegated_renderer_layer_impl_unittest.cc
index a641e00..711ef01 100644
--- a/cc/layers/delegated_renderer_layer_impl_unittest.cc
+++ b/cc/layers/delegated_renderer_layer_impl_unittest.cc
@@ -480,7 +480,7 @@ class DelegatedRendererLayerImplTestTransform
     gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
     gfx::Transform child_pass_transform;
-    child_pass_transform.Scale(0.8, 0.8);
+    child_pass_transform.Scale(0.8f, 0.8f);
     child_pass_transform.Translate(9.0, 9.0);
     gfx::Rect child_pass_clip_rect(21, 21, 3, 3);
     bool child_pass_clipped = false;
@@ -677,7 +677,7 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_NoSurface) {
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
-  expected.Scale(0.8, 0.8);
+  expected.Scale(0.8f, 0.8f);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
@@ -740,7 +740,7 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_NoSurface) {
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
-  expected.Scale(0.8, 0.8);
+  expected.Scale(0.8f, 0.8f);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
@@ -796,7 +796,7 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
-  expected.Scale(0.8, 0.8);
+  expected.Scale(0.8f, 0.8f);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
@@ -851,7 +851,7 @@ TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
             contrib_delegated_shared_quad_state->clip_rect.ToString());
   EXPECT_FALSE(contrib_delegated_shared_quad_state->is_clipped);
   expected.MakeIdentity();
-  expected.Scale(0.8, 0.8);
+  expected.Scale(0.8f, 0.8f);
   expected.Translate(9.0, 9.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected,
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index 1ab7a71..3d8948a 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -99,7 +99,7 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
       gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f));
   SkColor arbitrary_color = SkColorSetRGB(10, 20, 30);
   gfx::Transform arbitrary_transform;
-  arbitrary_transform.Scale3d(0.1, 0.2, 0.3);
+  arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
   FilterOperations arbitrary_filters;
   arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
   skia::RefPtr<SkImageFilter> arbitrary_filter =
@@ -213,7 +213,7 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
       gfx::RectF(arbitrary_point_f, gfx::SizeF(1.234f, 5.678f));
   SkColor arbitrary_color = SkColorSetRGB(10, 20, 30);
   gfx::Transform arbitrary_transform;
-  arbitrary_transform.Scale3d(0.1, 0.2, 0.3);
+  arbitrary_transform.Scale3d(0.1f, 0.2f, 0.3f);
   FilterOperations arbitrary_filters;
   arbitrary_filters.Append(FilterOperation::CreateOpacityFilter(0.5f));
   skia::RefPtr<SkImageFilter> arbitrary_filter =
diff --git a/cc/output/direct_renderer.cc b/cc/output/direct_renderer.cc
index aad41ed..0ee5adc 100644
--- a/cc/output/direct_renderer.cc
+++ b/cc/output/direct_renderer.cc
@@ -28,14 +28,14 @@ static gfx::Transform OrthoProjectionMatrix(float left,
   gfx::Transform proj;
   if (!delta_x || !delta_y)
     return proj;
-  proj.matrix().setDouble(0, 0, 2.0f / delta_x);
-  proj.matrix().setDouble(0, 3, -(right + left) / delta_x);
-  proj.matrix().setDouble(1, 1, 2.0f / delta_y);
-  proj.matrix().setDouble(1, 3, -(top + bottom) / delta_y);
+  proj.matrix().set(0, 0, 2.0f / delta_x);
+  proj.matrix().set(0, 3, -(right + left) / delta_x);
+  proj.matrix().set(1, 1, 2.0f / delta_y);
+  proj.matrix().set(1, 3, -(top + bottom) / delta_y);
 
   // Z component of vertices is always set to zero as we don't use the depth
   // buffer while drawing.
-  proj.matrix().setDouble(2, 2, 0);
+  proj.matrix().set(2, 2, 0);
 
   return proj;
 }
diff --git a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
index f0187aa..4d9578b 100644
--- a/cc/output/renderer_pixeltest.cc
+++ b/cc/output/renderer_pixeltest.cc
@@ -1329,10 +1329,10 @@ TEST_F(GLRendererPixelTest, AntiAliasingPerspective) {
 
   gfx::Rect red_rect(0, 0, 180, 500);
   gfx::Transform red_content_to_target_transform(
-      1.0,  2.4520,  10.6206, 19.0,
-      0.0,  0.3528,  5.9737,  9.5,
-      0.0, -0.2250, -0.9744,  0.0,
-      0.0,  0.0225,  0.0974,  1.0);
+      1.0f,  2.4520f,  10.6206f, 19.0f,
+      0.0f,  0.3528f,  5.9737f,  9.5f,
+      0.0f, -0.2250f, -0.9744f,  0.0f,
+      0.0f,  0.0225f,  0.0974f,  1.0f);
   scoped_ptr<SharedQuadState> red_shared_state =
       CreateTestSharedQuadState(red_content_to_target_transform, red_rect);
   scoped_ptr<SolidColorDrawQuad> red = SolidColorDrawQuad::Create();
diff --git a/cc/trees/layer_sorter_unittest.cc b/cc/trees/layer_sorter_unittest.cc
index b1d7b81..6669100 100644
--- a/cc/trees/layer_sorter_unittest.cc
+++ b/cc/trees/layer_sorter_unittest.cc
@@ -177,7 +177,7 @@ TEST(LayerSorterTest, LayersUnderPathologicalPerspectiveTransform) {
   // layer_a. When it is not clipped, its bounds will actually incorrectly
   // appear much smaller and the correct sorting dependency will not be found.
   gfx::Transform transform_b;
-  transform_b.Translate3d(0.0, 0.0, 0.7);
+  transform_b.Translate3d(0.f, 0.f, 0.7f);
   transform_b.RotateAboutYAxis(45.0);
   transform_b.Translate(-5.0, -5.0);
   LayerShape layer_b(10.f, 10.f, perspective_matrix * transform_b);
@@ -287,7 +287,7 @@ TEST(LayerSorterTest, VerifyConcidentLayerPrecisionLossResultsInDocumentOrder) {
   // in calculated order.
 
   gfx::Transform BehindMatrix;
-  BehindMatrix.Translate3d(0.0, 0.0, 0.999999);
+  BehindMatrix.Translate3d(0.f, 0.f, 0.999999f);
   BehindMatrix.RotateAboutXAxis(38.5);
   BehindMatrix.RotateAboutYAxis(77.0);
   gfx::Transform FrontMatrix;
diff --git a/cc/trees/layer_tree_host_common.cc b/cc/trees/layer_tree_host_common.cc
index b843675..378e7c8 100644
--- a/cc/trees/layer_tree_host_common.cc
+++ b/cc/trees/layer_tree_host_common.cc
@@ -1077,10 +1077,8 @@ static void PreCalculateMetaInformation(
 }
 
 static void RoundTranslationComponents(gfx::Transform* transform) {
-  transform->matrix().
-      setDouble(0, 3, MathUtil::Round(transform->matrix().getDouble(0, 3)));
-  transform->matrix().
-      setDouble(1, 3, MathUtil::Round(transform->matrix().getDouble(1, 3)));
+  transform->matrix().set(0, 3, MathUtil::Round(transform->matrix().get(0, 3)));
+  transform->matrix().set(1, 3, MathUtil::Round(transform->matrix().get(1, 3)));
 }
 
 template <typename LayerType>
diff --git a/cc/trees/layer_tree_host_common_unittest.cc b/cc/trees/layer_tree_host_common_unittest.cc
index 5ce1034..6847f9c 100644
--- a/cc/trees/layer_tree_host_common_unittest.cc
+++ b/cc/trees/layer_tree_host_common_unittest.cc
@@ -343,7 +343,7 @@ TEST_F(LayerTreeHostCommonTest, TransformsForSingleLayer) {
   // Case 4: A change in actual position affects both the draw transform and
   // screen space transform.
   gfx::Transform position_transform;
-  position_transform.Translate(0.0, 1.2);
+  position_transform.Translate(0.f, 1.2f);
   SetLayerPropertiesForTesting(layer.get(),
                                identity_matrix,
                                identity_matrix,
@@ -551,7 +551,7 @@ TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
 
   // Case 2: parent's position affects child and grand_child.
   gfx::Transform parent_position_transform;
-  parent_position_transform.Translate(0.0, 1.2);
+  parent_position_transform.Translate(0.f, 1.2f);
   SetLayerPropertiesForTesting(parent.get(),
                                identity_matrix,
                                identity_matrix,
@@ -629,7 +629,7 @@ TEST_F(LayerTreeHostCommonTest, TransformsForSimpleHierarchy) {
   // does not preserve3D. When it gives its hierarchy to the grand_child, it
   // should be flattened to 2D.
   gfx::Transform parent_sublayer_matrix;
-  parent_sublayer_matrix.Scale3d(10.0, 10.0, 3.3);
+  parent_sublayer_matrix.Scale3d(10.f, 10.f, 3.3f);
   // Sublayer matrix is applied to the anchor point of the parent layer.
   parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
@@ -730,11 +730,11 @@ TEST_F(LayerTreeHostCommonTest, TransformsForSingleRenderSurface) {
   child->SetForceRenderSurface(true);
 
   gfx::Transform parent_layer_transform;
-  parent_layer_transform.Scale3d(1.0, 0.9, 1.0);
+  parent_layer_transform.Scale3d(1.f, 0.9f, 1.f);
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(25.0, 30.0);
   gfx::Transform parent_sublayer_matrix;
-  parent_sublayer_matrix.Scale3d(0.9, 1.0, 3.3);
+  parent_sublayer_matrix.Scale3d(0.9f, 1.f, 3.3f);
 
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
@@ -876,8 +876,8 @@ TEST_F(LayerTreeHostCommonTest, SeparateRenderTargetRequirementWithClipping) {
   EXPECT_FALSE(grand_child->render_surface());
 
   // One-time setup of root layer
-  parent_layer_transform.Scale3d(1.0, 0.9, 1.0);
-  parent_sublayer_matrix.Scale3d(0.9, 1.0, 3.3);
+  parent_layer_transform.Scale3d(1.f, 0.9f, 1.f);
+  parent_sublayer_matrix.Scale3d(0.9f, 1.f, 3.3f);
   child_layer_matrix.Rotate(20.0);
 
   SetLayerPropertiesForTesting(root.get(),
@@ -948,8 +948,8 @@ TEST_F(LayerTreeHostCommonTest,
   EXPECT_FALSE(grand_child->render_surface());
 
   // One-time setup of root layer
-  parent_layer_transform.Scale3d(1.0, 0.9, 1.0);
-  parent_sublayer_matrix.Scale3d(0.9, 1.0, 3.3);
+  parent_layer_transform.Scale3d(1.f, 0.9f, 1.f);
+  parent_sublayer_matrix.Scale3d(0.9f, 1.f, 3.3f);
   child_layer_matrix.Rotate(20.0);
 
   SetLayerPropertiesForTesting(root.get(),
@@ -1024,7 +1024,7 @@ TEST_F(LayerTreeHostCommonTest, TransformsForReplica) {
   gfx::Transform parent_translation_to_anchor;
   parent_translation_to_anchor.Translate(2.5, 3.0);
   gfx::Transform parent_sublayer_matrix;
-  parent_sublayer_matrix.Scale3d(10.0, 10.0, 3.3);
+  parent_sublayer_matrix.Scale3d(10.f, 10.f, 3.3f);
   gfx::Transform parent_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor) * parent_translation_to_anchor *
@@ -6245,7 +6245,7 @@ TEST_F(LayerTreeHostCommonTest, SurfaceLayerTransformsInHighDPI) {
   perspective_matrix.ApplyPerspectiveDepth(2.0);
 
   gfx::Transform scale_small_matrix;
-  scale_small_matrix.Scale(1.0 / 10.0, 1.0 / 12.0);
+  scale_small_matrix.Scale(SK_MScalar1 / 10.f, SK_MScalar1 / 12.f);
 
   scoped_refptr<Layer> root = Layer::Create();
 
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index c184c67..bab6d20 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -4748,7 +4748,7 @@ TEST_F(LayerTreeHostImplTest, SurfaceTextureCaching) {
 
   // Change location of the intermediate layer
   gfx::Transform transform = intermediate_layer_ptr->transform();
-  transform.matrix().setDouble(0, 3, 1.0001);
+  transform.matrix().set(0, 3, 1.0001f);
   intermediate_layer_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
@@ -4934,7 +4934,7 @@ TEST_F(LayerTreeHostImplTest, SurfaceTextureCachingNoPartialSwap) {
 
   // Change location of the intermediate layer
   gfx::Transform transform = intermediate_layer_ptr->transform();
-  transform.matrix().setDouble(0, 3, 1.0001);
+  transform.matrix().set(0, 3, 1.0001f);
   intermediate_layer_ptr->SetTransform(transform);
   {
     LayerTreeHostImpl::FrameData frame;
diff --git a/cc/trees/layer_tree_host_pixeltest_filters.cc b/cc/trees/layer_tree_host_pixeltest_filters.cc
index 7068b4b..4055376 100644
--- a/cc/trees/layer_tree_host_pixeltest_filters.cc
+++ b/cc/trees/layer_tree_host_pixeltest_filters.cc
@@ -129,8 +129,8 @@ TEST_F(LayerTreeHostFiltersPixelTest, BackgroundFilterBlurOffAxis) {
   blur->SetBackgroundFilters(filters);
 
 #if defined(OS_WIN)
-  // Windows has 151 pixels off by at most 2: crbug.com/225027
-  float percentage_pixels_large_error = 0.3775f;  // 151px / (200*200)
+  // Windows has 153 pixels off by at most 2: crbug.com/225027
+  float percentage_pixels_large_error = 0.3825f;  // 153px / (200*200)
   float percentage_pixels_small_error = 0.0f;
   float average_error_allowed_in_bad_pixels = 1.f;
   int large_error_allowed = 2;
diff --git a/cc/trees/quad_culler_unittest.cc b/cc/trees/quad_culler_unittest.cc
index 120e007..ea64287 100644
--- a/cc/trees/quad_culler_unittest.cc
+++ b/cc/trees/quad_culler_unittest.cc
@@ -126,6 +126,7 @@ class QuadCullerTest : public testing::Test {
   FakeLayerTreeHostImpl host_impl_;
   int layer_id_;
 
+ private:
   DISALLOW_COPY_AND_ASSIGN(QuadCullerTest);
 };
 
@@ -368,8 +369,8 @@ TEST_F(QuadCullerTest, VerifyCullCenterTileNonIntegralSize1) {
   // Make the root layer's quad have extent (99.1, 99.1) -> (200.9, 200.9) to
   // make sure it doesn't get culled due to transform rounding.
   gfx::Transform root_transform;
-  root_transform.Translate(99.1, 99.1);
-  root_transform.Scale(1.018, 1.018);
+  root_transform.Translate(99.1f, 99.1f);
+  root_transform.Scale(1.018f, 1.018f);
 
   root_rect = child_rect = gfx::Rect(0, 0, 100, 100);
 
@@ -416,8 +417,8 @@ TEST_F(QuadCullerTest, VerifyCullCenterTileNonIntegralSize2) {
   // Make the child's quad slightly smaller than, and centred over, the root
   // layer tile.  Verify the child does not cause the quad below to be culled
   // due to rounding.
-  child_transform.Translate(100.1, 100.1);
-  child_transform.Scale(0.982, 0.982);
+  child_transform.Translate(100.1f, 100.1f);
+  child_transform.Scale(0.982f, 0.982f);
 
   gfx::Transform root_transform;
   root_transform.Translate(100, 100);
diff --git a/content/browser/renderer_host/input/gesture_event_filter.cc b/content/browser/renderer_host/input/gesture_event_filter.cc
index c2ff887..9a80a06 100644
--- a/content/browser/renderer_host/input/gesture_event_filter.cc
+++ b/content/browser/renderer_host/input/gesture_event_filter.cc
@@ -393,13 +393,18 @@ void GestureEventFilter::MergeOrInsertScrollAndPinchEvent(
         PreconcatTransform(GetTransformForEvent(*last_event));
   }
   coalesced_gesture_events_.pop_back();
-  float combined_scale = combined_scroll_pinch_.matrix().getDouble(0, 0);
+  float combined_scale =
+      SkMScalarToFloat(combined_scroll_pinch_.matrix().get(0, 0));
+  float combined_scroll_pinch_x =
+      SkMScalarToFloat(combined_scroll_pinch_.matrix().get(0, 3));
+  float combined_scroll_pinch_y =
+      SkMScalarToFloat(combined_scroll_pinch_.matrix().get(1, 3));
   scroll_event.event.data.scrollUpdate.deltaX =
-      (combined_scroll_pinch_.matrix().getDouble(0, 3) + pinch_event.event.x)
-          / combined_scale - pinch_event.event.x;
+      (combined_scroll_pinch_x + pinch_event.event.x) / combined_scale -
+      pinch_event.event.x;
   scroll_event.event.data.scrollUpdate.deltaY =
-      (combined_scroll_pinch_.matrix().getDouble(1, 3) + pinch_event.event.y)
-          / combined_scale - pinch_event.event.y;
+      (combined_scroll_pinch_y + pinch_event.event.y) / combined_scale -
+      pinch_event.event.y;
   coalesced_gesture_events_.push_back(scroll_event);
   pinch_event.event.data.pinchUpdate.scale = combined_scale;
   coalesced_gesture_events_.push_back(pinch_event);
diff --git a/content/common/cc_messages.cc b/content/common/cc_messages.cc
index a122ed8..964fa86 100644
--- a/content/common/cc_messages.cc
+++ b/content/common/cc_messages.cc
@@ -226,22 +226,22 @@ void ParamTraits<skia::RefPtr<SkImageFilter> >::Log(
 
 void ParamTraits<gfx::Transform>::Write(
     Message* m, const param_type& p) {
-  WriteParam(m, p.matrix().getDouble(0, 0));
-  WriteParam(m, p.matrix().getDouble(1, 0));
-  WriteParam(m, p.matrix().getDouble(2, 0));
-  WriteParam(m, p.matrix().getDouble(3, 0));
-  WriteParam(m, p.matrix().getDouble(0, 1));
-  WriteParam(m, p.matrix().getDouble(1, 1));
-  WriteParam(m, p.matrix().getDouble(2, 1));
-  WriteParam(m, p.matrix().getDouble(3, 1));
-  WriteParam(m, p.matrix().getDouble(0, 2));
-  WriteParam(m, p.matrix().getDouble(1, 2));
-  WriteParam(m, p.matrix().getDouble(2, 2));
-  WriteParam(m, p.matrix().getDouble(3, 2));
-  WriteParam(m, p.matrix().getDouble(0, 3));
-  WriteParam(m, p.matrix().getDouble(1, 3));
-  WriteParam(m, p.matrix().getDouble(2, 3));
-  WriteParam(m, p.matrix().getDouble(3, 3));
+  WriteParam(m, p.matrix().get(0, 0));
+  WriteParam(m, p.matrix().get(1, 0));
+  WriteParam(m, p.matrix().get(2, 0));
+  WriteParam(m, p.matrix().get(3, 0));
+  WriteParam(m, p.matrix().get(0, 1));
+  WriteParam(m, p.matrix().get(1, 1));
+  WriteParam(m, p.matrix().get(2, 1));
+  WriteParam(m, p.matrix().get(3, 1));
+  WriteParam(m, p.matrix().get(0, 2));
+  WriteParam(m, p.matrix().get(1, 2));
+  WriteParam(m, p.matrix().get(2, 2));
+  WriteParam(m, p.matrix().get(3, 2));
+  WriteParam(m, p.matrix().get(0, 3));
+  WriteParam(m, p.matrix().get(1, 3));
+  WriteParam(m, p.matrix().get(2, 3));
+  WriteParam(m, p.matrix().get(3, 3));
 }
 
 bool ParamTraits<gfx::Transform>::Read(
@@ -249,8 +249,8 @@ bool ParamTraits<gfx::Transform>::Read(
   // Note: In this function, "m12" means 1st row, 2nd column of the matrix.
   // This is consistent with Skia's row-column notation, but backwards from
   // WebCore's column-row notation.
-  double m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34,
-         m41, m42, m43, m44;
+  SkMScalar m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41,
+      m42, m43, m44;
 
   bool success =
       ReadParam(m, iter, &m11) &&
@@ -271,22 +271,22 @@ bool ParamTraits<gfx::Transform>::Read(
       ReadParam(m, iter, &m44);
 
   if (success) {
-    r->matrix().setDouble(0, 0, m11);
-    r->matrix().setDouble(1, 0, m21);
-    r->matrix().setDouble(2, 0, m31);
-    r->matrix().setDouble(3, 0, m41);
-    r->matrix().setDouble(0, 1, m12);
-    r->matrix().setDouble(1, 1, m22);
-    r->matrix().setDouble(2, 1, m32);
-    r->matrix().setDouble(3, 1, m42);
-    r->matrix().setDouble(0, 2, m13);
-    r->matrix().setDouble(1, 2, m23);
-    r->matrix().setDouble(2, 2, m33);
-    r->matrix().setDouble(3, 2, m43);
-    r->matrix().setDouble(0, 3, m14);
-    r->matrix().setDouble(1, 3, m24);
-    r->matrix().setDouble(2, 3, m34);
-    r->matrix().setDouble(3, 3, m44);
+    r->matrix().set(0, 0, m11);
+    r->matrix().set(1, 0, m21);
+    r->matrix().set(2, 0, m31);
+    r->matrix().set(3, 0, m41);
+    r->matrix().set(0, 1, m12);
+    r->matrix().set(1, 1, m22);
+    r->matrix().set(2, 1, m32);
+    r->matrix().set(3, 1, m42);
+    r->matrix().set(0, 2, m13);
+    r->matrix().set(1, 2, m23);
+    r->matrix().set(2, 2, m33);
+    r->matrix().set(3, 2, m43);
+    r->matrix().set(0, 3, m14);
+    r->matrix().set(1, 3, m24);
+    r->matrix().set(2, 3, m34);
+    r->matrix().set(3, 3, m44);
   }
 
   return success;
@@ -295,37 +295,37 @@ bool ParamTraits<gfx::Transform>::Read(
 void ParamTraits<gfx::Transform>::Log(
     const param_type& p, std::string* l) {
   l->append("(");
-  LogParam(p.matrix().getDouble(0, 0), l);
+  LogParam(p.matrix().get(0, 0), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(1, 0), l);
+  LogParam(p.matrix().get(1, 0), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(2, 0), l);
+  LogParam(p.matrix().get(2, 0), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(3, 0), l);
+  LogParam(p.matrix().get(3, 0), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(0, 1), l);
+  LogParam(p.matrix().get(0, 1), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(1, 1), l);
+  LogParam(p.matrix().get(1, 1), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(2, 1), l);
+  LogParam(p.matrix().get(2, 1), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(3, 1), l);
+  LogParam(p.matrix().get(3, 1), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(0, 2), l);
+  LogParam(p.matrix().get(0, 2), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(1, 2), l);
+  LogParam(p.matrix().get(1, 2), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(2, 2), l);
+  LogParam(p.matrix().get(2, 2), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(3, 2), l);
+  LogParam(p.matrix().get(3, 2), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(0, 3), l);
+  LogParam(p.matrix().get(0, 3), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(1, 3), l);
+  LogParam(p.matrix().get(1, 3), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(2, 3), l);
+  LogParam(p.matrix().get(2, 3), l);
   l->append(", ");
-  LogParam(p.matrix().getDouble(3, 3), l);
+  LogParam(p.matrix().get(3, 3), l);
   l->append(") ");
 }
 
diff --git a/ui/gfx/skia_util.cc b/ui/gfx/skia_util.cc
index 1d05d1a..bb7cde7 100644
--- a/ui/gfx/skia_util.cc
+++ b/ui/gfx/skia_util.cc
@@ -50,15 +50,15 @@ RectF SkRectToRectF(const SkRect& rect) {
 void TransformToFlattenedSkMatrix(const gfx::Transform& transform,
                                   SkMatrix* flattened) {
   // Convert from 4x4 to 3x3 by dropping the third row and column.
-  flattened->set(0, SkDoubleToScalar(transform.matrix().getDouble(0, 0)));
-  flattened->set(1, SkDoubleToScalar(transform.matrix().getDouble(0, 1)));
-  flattened->set(2, SkDoubleToScalar(transform.matrix().getDouble(0, 3)));
-  flattened->set(3, SkDoubleToScalar(transform.matrix().getDouble(1, 0)));
-  flattened->set(4, SkDoubleToScalar(transform.matrix().getDouble(1, 1)));
-  flattened->set(5, SkDoubleToScalar(transform.matrix().getDouble(1, 3)));
-  flattened->set(6, SkDoubleToScalar(transform.matrix().getDouble(3, 0)));
-  flattened->set(7, SkDoubleToScalar(transform.matrix().getDouble(3, 1)));
-  flattened->set(8, SkDoubleToScalar(transform.matrix().getDouble(3, 3)));
+  flattened->set(0, SkMScalarToScalar(transform.matrix().get(0, 0)));
+  flattened->set(1, SkMScalarToScalar(transform.matrix().get(0, 1)));
+  flattened->set(2, SkMScalarToScalar(transform.matrix().get(0, 3)));
+  flattened->set(3, SkMScalarToScalar(transform.matrix().get(1, 0)));
+  flattened->set(4, SkMScalarToScalar(transform.matrix().get(1, 1)));
+  flattened->set(5, SkMScalarToScalar(transform.matrix().get(1, 3)));
+  flattened->set(6, SkMScalarToScalar(transform.matrix().get(3, 0)));
+  flattened->set(7, SkMScalarToScalar(transform.matrix().get(3, 1)));
+  flattened->set(8, SkMScalarToScalar(transform.matrix().get(3, 3)));
 }
 
 skia::RefPtr<SkShader> CreateImageRepShader(const gfx::ImageSkiaRep& image_rep,
diff --git a/ui/gfx/transform.cc b/ui/gfx/transform.cc
index 9022ece..ac62006 100644
--- a/ui/gfx/transform.cc
+++ b/ui/gfx/transform.cc
@@ -24,11 +24,11 @@ namespace gfx {
 namespace {
 
 // Taken from SkMatrix44.
-const SkMScalar kEpsilon = 1e-8;
+const SkMScalar kEpsilon = 1e-8f;
 
 SkMScalar TanDegrees(double degrees) {
-  SkMScalar radians = degrees * M_PI / 180;
-  return std::tan(radians);
+  double radians = degrees * M_PI / 180;
+  return SkDoubleToMScalar(std::tan(radians));
 }
 
 }  // namespace
@@ -169,7 +169,7 @@ void Transform::Translate3d(SkMScalar x, SkMScalar y, SkMScalar z) {
   matrix_.preTranslate(x, y, z);
 }
 
-void Transform::SkewX(SkMScalar angle_x) {
+void Transform::SkewX(double angle_x) {
   if (matrix_.isIdentity())
     matrix_.set(0, 1, TanDegrees(angle_x));
   else {
@@ -179,7 +179,7 @@ void Transform::SkewX(SkMScalar angle_x) {
   }
 }
 
-void Transform::SkewY(SkMScalar angle_y) {
+void Transform::SkewY(double angle_y) {
   if (matrix_.isIdentity())
     matrix_.set(1, 0, TanDegrees(angle_y));
   else {
@@ -428,7 +428,7 @@ bool Transform::TransformRectReverse(RectF* rect) const {
   return true;
 }
 
-bool Transform::Blend(const Transform& from, SkMScalar progress) {
+bool Transform::Blend(const Transform& from, double progress) {
   DecomposedTransform to_decomp;
   DecomposedTransform from_decomp;
   if (!DecomposeTransform(&to_decomp, *this) ||
diff --git a/ui/gfx/transform.h b/ui/gfx/transform.h
index 0c68656..0bae588 100644
--- a/ui/gfx/transform.h
+++ b/ui/gfx/transform.h
@@ -96,8 +96,8 @@ class UI_EXPORT Transform {
 
   // Applies the current transformation on a skew and assigns the result
   // to |this|.
-  void SkewX(SkMScalar angle_x);
-  void SkewY(SkMScalar angle_y);
+  void SkewX(double angle_x);
+  void SkewY(double angle_y);
 
   // Applies the current transformation on a perspective transform and assigns
   // the result to |this|.
@@ -216,7 +216,7 @@ class UI_EXPORT Transform {
   // you're going to be calling this rapidly (e.g., in an animation) you should
   // decompose once using gfx::DecomposeTransforms and reuse your
   // DecomposedTransform.
-  bool Blend(const Transform& from, SkMScalar progress);
+  bool Blend(const Transform& from, double progress);
 
   // Returns |this| * |other|.
   Transform operator*(const Transform& other) const {
diff --git a/ui/gfx/transform_unittest.cc b/ui/gfx/transform_unittest.cc
index 4394af6789..34e129a 100644
--- a/ui/gfx/transform_unittest.cc
+++ b/ui/gfx/transform_unittest.cc
@@ -90,22 +90,22 @@ bool MatricesAreNearlyEqual(const Transform& lhs,
 
 void InitializeTestMatrix(Transform* transform) {
   SkMatrix44& matrix = transform->matrix();
-  matrix.setDouble(0, 0, 10.0);
-  matrix.setDouble(1, 0, 11.0);
-  matrix.setDouble(2, 0, 12.0);
-  matrix.setDouble(3, 0, 13.0);
-  matrix.setDouble(0, 1, 14.0);
-  matrix.setDouble(1, 1, 15.0);
-  matrix.setDouble(2, 1, 16.0);
-  matrix.setDouble(3, 1, 17.0);
-  matrix.setDouble(0, 2, 18.0);
-  matrix.setDouble(1, 2, 19.0);
-  matrix.setDouble(2, 2, 20.0);
-  matrix.setDouble(3, 2, 21.0);
-  matrix.setDouble(0, 3, 22.0);
-  matrix.setDouble(1, 3, 23.0);
-  matrix.setDouble(2, 3, 24.0);
-  matrix.setDouble(3, 3, 25.0);
+  matrix.set(0, 0, 10.f);
+  matrix.set(1, 0, 11.f);
+  matrix.set(2, 0, 12.f);
+  matrix.set(3, 0, 13.f);
+  matrix.set(0, 1, 14.f);
+  matrix.set(1, 1, 15.f);
+  matrix.set(2, 1, 16.f);
+  matrix.set(3, 1, 17.f);
+  matrix.set(0, 2, 18.f);
+  matrix.set(1, 2, 19.f);
+  matrix.set(2, 2, 20.f);
+  matrix.set(3, 2, 21.f);
+  matrix.set(0, 3, 22.f);
+  matrix.set(1, 3, 23.f);
+  matrix.set(2, 3, 24.f);
+  matrix.set(3, 3, 25.f);
 
   // Sanity check
   EXPECT_ROW1_EQ(10.0f, 14.0f, 18.0f, 22.0f, (*transform));
@@ -116,22 +116,22 @@ void InitializeTestMatrix(Transform* transform) {
 
 void InitializeTestMatrix2(Transform* transform) {
   SkMatrix44& matrix = transform->matrix();
-  matrix.setDouble(0, 0, 30.0);
-  matrix.setDouble(1, 0, 31.0);
-  matrix.setDouble(2, 0, 32.0);
-  matrix.setDouble(3, 0, 33.0);
-  matrix.setDouble(0, 1, 34.0);
-  matrix.setDouble(1, 1, 35.0);
-  matrix.setDouble(2, 1, 36.0);
-  matrix.setDouble(3, 1, 37.0);
-  matrix.setDouble(0, 2, 38.0);
-  matrix.setDouble(1, 2, 39.0);
-  matrix.setDouble(2, 2, 40.0);
-  matrix.setDouble(3, 2, 41.0);
-  matrix.setDouble(0, 3, 42.0);
-  matrix.setDouble(1, 3, 43.0);
-  matrix.setDouble(2, 3, 44.0);
-  matrix.setDouble(3, 3, 45.0);
+  matrix.set(0, 0, 30.f);
+  matrix.set(1, 0, 31.f);
+  matrix.set(2, 0, 32.f);
+  matrix.set(3, 0, 33.f);
+  matrix.set(0, 1, 34.f);
+  matrix.set(1, 1, 35.f);
+  matrix.set(2, 1, 36.f);
+  matrix.set(3, 1, 37.f);
+  matrix.set(0, 2, 38.f);
+  matrix.set(1, 2, 39.f);
+  matrix.set(2, 2, 40.f);
+  matrix.set(3, 2, 41.f);
+  matrix.set(0, 3, 42.f);
+  matrix.set(1, 3, 43.f);
+  matrix.set(2, 3, 44.f);
+  matrix.set(3, 3, 45.f);
 
   // Sanity check
   EXPECT_ROW1_EQ(30.0f, 34.0f, 38.0f, 42.0f, (*transform));
@@ -738,14 +738,21 @@ TEST(XFormTest, CanBlend180DegreeRotation) {
   for (size_t index = 0; index < ARRAYSIZE_UNSAFE(axes); ++index) {
     for (int i = -5; i < 15; ++i) {
       Transform to;
-      to.RotateAbout(axes[index], 180);
+      to.RotateAbout(axes[index], 180.0);
       double t = i / 9.0;
       EXPECT_TRUE(to.Blend(from, t));
 
-      Transform expected;
-      expected.RotateAbout(axes[index], 180 * t);
+      // A 180 degree rotation is exactly opposite on the sphere, therefore
+      // either great circle arc to it is equivalent (and numerical precision
+      // will determine which is closer).  Test both directions.
+      Transform expected1;
+      expected1.RotateAbout(axes[index], 180.0 * t);
+      Transform expected2;
+      expected2.RotateAbout(axes[index], -180.0 * t);
 
-      EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
+      EXPECT_TRUE(MatricesAreNearlyEqual(expected1, to) ||
+                  MatricesAreNearlyEqual(expected2, to))
+          << "axis: " << index << ", i: " << i;
     }
   }
 }
@@ -757,9 +764,9 @@ TEST(XFormTest, BlendScale) {
     to.Scale3d(5, 4, 3);
     double t = i / 9.0;
     EXPECT_TRUE(to.Blend(from, t));
-    EXPECT_FLOAT_EQ(t * 4 + 1, to.matrix().get(0, 0));
-    EXPECT_FLOAT_EQ(t * 3 + 1, to.matrix().get(1, 1));
-    EXPECT_FLOAT_EQ(t * 2 + 1, to.matrix().get(2, 2));
+    EXPECT_FLOAT_EQ(t * 4 + 1, to.matrix().get(0, 0)) << "i: " << i;
+    EXPECT_FLOAT_EQ(t * 3 + 1, to.matrix().get(1, 1)) << "i: " << i;
+    EXPECT_FLOAT_EQ(t * 2 + 1, to.matrix().get(2, 2)) << "i: " << i;
   }
 }
 
@@ -767,12 +774,12 @@ TEST(XFormTest, BlendSkew) {
   Transform from;
   for (int i = 0; i < 2; ++i) {
     Transform to;
-    to.SkewX(20);
-    to.SkewY(10);
+    to.SkewX(10);
+    to.SkewY(5);
     double t = i;
     Transform expected;
-    expected.SkewX(t * 20);
-    expected.SkewY(t * 10);
+    expected.SkewX(t * 10);
+    expected.SkewY(t * 5);
     EXPECT_TRUE(to.Blend(from, t));
     EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
   }
@@ -1201,7 +1208,7 @@ TEST(XFormTest, VerifyBlendForCompositeTransform) {
   // We short circuit if blend is >= 1, so to check the numerics, we will
   // check that we get close to what we expect when we're nearly done
   // interpolating.
-  to.Blend(from, .99999);
+  to.Blend(from, .99999f);
 
   // Recomposing the matrix results in a normalized matrix, so to verify we
   // need to normalize the expectedEndOfAnimation before comparing elements.
@@ -1259,14 +1266,17 @@ TEST(XFormTest, FactorTRS) {
     EXPECT_TRUE(success);
     EXPECT_FLOAT_EQ(decomp.translate[0], degrees * 2);
     EXPECT_FLOAT_EQ(decomp.translate[1], -degrees * 3);
-    double rotation = std::acos(decomp.quaternion[3]) * 360.0 / M_PI;
+    double rotation =
+        std::acos(SkMScalarToDouble(decomp.quaternion[3])) * 360.0 / M_PI;
     while (rotation < 0.0)
       rotation += 360.0;
     while (rotation > 360.0)
       rotation -= 360.0;
-    EXPECT_FLOAT_EQ(rotation, degrees);
-    EXPECT_FLOAT_EQ(decomp.scale[0], degrees + 1);
-    EXPECT_FLOAT_EQ(decomp.scale[1], 2 * degrees + 1);
+
+    const float epsilon = 0.00015f;
+    EXPECT_NEAR(rotation, degrees, epsilon);
+    EXPECT_NEAR(decomp.scale[0], degrees + 1, epsilon);
+    EXPECT_NEAR(decomp.scale[1], 2 * degrees + 1, epsilon);
   }
 }
 
@@ -1282,15 +1292,15 @@ TEST(XFormTest, IntegerTranslation) {
   EXPECT_TRUE(transform.IsIdentityOrIntegerTranslation());
 
   transform.MakeIdentity();
-  transform.Translate3d(4.5, 0, 0);
+  transform.Translate3d(4.5f, 0, 0);
   EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
 
   transform.MakeIdentity();
-  transform.Translate3d(0, -6.7, 0);
+  transform.Translate3d(0, -6.7f, 0);
   EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
 
   transform.MakeIdentity();
-  transform.Translate3d(0, 0, 8.9);
+  transform.Translate3d(0, 0, 8.9f);
   EXPECT_FALSE(transform.IsIdentityOrIntegerTranslation());
 }
 
@@ -1329,10 +1339,10 @@ TEST(XFormTest, verifyMatrixInversion) {
     // Try to invert a matrix that is not invertible.
     // The inverse() function should reset the output matrix to identity.
     gfx::Transform uninvertible;
-    uninvertible.matrix().setDouble(0, 0, 0.0);
-    uninvertible.matrix().setDouble(1, 1, 0.0);
-    uninvertible.matrix().setDouble(2, 2, 0.0);
-    uninvertible.matrix().setDouble(3, 3, 0.0);
+    uninvertible.matrix().set(0, 0, 0.f);
+    uninvertible.matrix().set(1, 1, 0.f);
+    uninvertible.matrix().set(2, 2, 0.f);
+    uninvertible.matrix().set(3, 3, 0.f);
     EXPECT_FALSE(uninvertible.IsInvertible());
 
     gfx::Transform inverse_of_uninvertible;
@@ -1495,67 +1505,67 @@ TEST(XFormTest, verifyEqualsBooleanOperator) {
   // return false.
   Transform D;
   D = A;
-  D.matrix().setDouble(0, 0, 0.0);
+  D.matrix().set(0, 0, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(1, 0, 0.0);
+  D.matrix().set(1, 0, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(2, 0, 0.0);
+  D.matrix().set(2, 0, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(3, 0, 0.0);
+  D.matrix().set(3, 0, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(0, 1, 0.0);
+  D.matrix().set(0, 1, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(1, 1, 0.0);
+  D.matrix().set(1, 1, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(2, 1, 0.0);
+  D.matrix().set(2, 1, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(3, 1, 0.0);
+  D.matrix().set(3, 1, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(0, 2, 0.0);
+  D.matrix().set(0, 2, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(1, 2, 0.0);
+  D.matrix().set(1, 2, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(2, 2, 0.0);
+  D.matrix().set(2, 2, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(3, 2, 0.0);
+  D.matrix().set(3, 2, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(0, 3, 0.0);
+  D.matrix().set(0, 3, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(1, 3, 0.0);
+  D.matrix().set(1, 3, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(2, 3, 0.0);
+  D.matrix().set(2, 3, 0.f);
   EXPECT_FALSE(A == D);
 
   D = A;
-  D.matrix().setDouble(3, 3, 0.0);
+  D.matrix().set(3, 3, 0.f);
   EXPECT_FALSE(A == D);
 }
 
@@ -1945,23 +1955,23 @@ TEST(XFormTest, verifyHasPerspective) {
   EXPECT_FALSE(A.HasPerspective());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 0, -1.0);
+  A.matrix().set(3, 0, -1.f);
   EXPECT_TRUE(A.HasPerspective());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 1, -1.0);
+  A.matrix().set(3, 1, -1.f);
   EXPECT_TRUE(A.HasPerspective());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 2, -0.3);
+  A.matrix().set(3, 2, -0.3f);
   EXPECT_TRUE(A.HasPerspective());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 3, 0.5);
+  A.matrix().set(3, 3, 0.5f);
   EXPECT_TRUE(A.HasPerspective());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 3, 0.0);
+  A.matrix().set(3, 3, 0.f);
   EXPECT_TRUE(A.HasPerspective());
 }
 
@@ -2002,14 +2012,14 @@ TEST(XFormTest, verifyIsInvertible) {
   // to zero (i.e. camera positioned at the origin), is not invertible.
   A.MakeIdentity();
   A.ApplyPerspectiveDepth(1.0);
-  A.matrix().setDouble(3, 3, 0.0);
+  A.matrix().set(3, 3, 0.f);
   EXPECT_FALSE(A.IsInvertible());
 
   // Adding more to a non-invertible matrix will not make it invertible in the
   // general case.
   A.MakeIdentity();
   A.ApplyPerspectiveDepth(1.0);
-  A.matrix().setDouble(3, 3, 0.0);
+  A.matrix().set(3, 3, 0.f);
   A.Scale3d(6.0, 7.0, 8.0);
   A.RotateAboutXAxis(10.0);
   A.RotateAboutYAxis(20.0);
@@ -2019,10 +2029,10 @@ TEST(XFormTest, verifyIsInvertible) {
 
   // A degenerate matrix of all zeros is not invertible.
   A.MakeIdentity();
-  A.matrix().setDouble(0, 0, 0.0);
-  A.matrix().setDouble(1, 1, 0.0);
-  A.matrix().setDouble(2, 2, 0.0);
-  A.matrix().setDouble(3, 3, 0.0);
+  A.matrix().set(0, 0, 0.f);
+  A.matrix().set(1, 1, 0.f);
+  A.matrix().set(2, 2, 0.f);
+  A.matrix().set(3, 3, 0.f);
   EXPECT_FALSE(A.IsInvertible());
 }
 
@@ -2038,67 +2048,67 @@ TEST(XFormTest, verifyIsIdentity) {
   // Modifying any one individual element should cause the matrix to no longer
   // be identity.
   A.MakeIdentity();
-  A.matrix().setDouble(0, 0, 2.0);
+  A.matrix().set(0, 0, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 0, 2.0);
+  A.matrix().set(1, 0, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 0, 2.0);
+  A.matrix().set(2, 0, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 0, 2.0);
+  A.matrix().set(3, 0, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(0, 1, 2.0);
+  A.matrix().set(0, 1, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 1, 2.0);
+  A.matrix().set(1, 1, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 1, 2.0);
+  A.matrix().set(2, 1, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 1, 2.0);
+  A.matrix().set(3, 1, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(0, 2, 2.0);
+  A.matrix().set(0, 2, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 2, 2.0);
+  A.matrix().set(1, 2, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 2, 2.0);
+  A.matrix().set(2, 2, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 2, 2.0);
+  A.matrix().set(3, 2, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(0, 3, 2.0);
+  A.matrix().set(0, 3, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 3, 2.0);
+  A.matrix().set(1, 3, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 3, 2.0);
+  A.matrix().set(2, 3, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 3, 2.0);
+  A.matrix().set(3, 3, 2.f);
   EXPECT_FALSE(A.IsIdentity());
 }
 
@@ -2116,70 +2126,70 @@ TEST(XFormTest, verifyIsIdentityOrTranslation) {
   // (2, 3) are the translation components, so modifying them should still
   // return true.
   A.MakeIdentity();
-  A.matrix().setDouble(0, 0, 2.0);
+  A.matrix().set(0, 0, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 0, 2.0);
+  A.matrix().set(1, 0, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 0, 2.0);
+  A.matrix().set(2, 0, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 0, 2.0);
+  A.matrix().set(3, 0, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(0, 1, 2.0);
+  A.matrix().set(0, 1, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 1, 2.0);
+  A.matrix().set(1, 1, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 1, 2.0);
+  A.matrix().set(2, 1, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 1, 2.0);
+  A.matrix().set(3, 1, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(0, 2, 2.0);
+  A.matrix().set(0, 2, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 2, 2.0);
+  A.matrix().set(1, 2, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 2, 2.0);
+  A.matrix().set(2, 2, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 2, 2.0);
+  A.matrix().set(3, 2, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(0, 3, 2.0);
+  A.matrix().set(0, 3, 2.f);
   EXPECT_TRUE(A.IsIdentityOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(1, 3, 2.0);
+  A.matrix().set(1, 3, 2.f);
   EXPECT_TRUE(A.IsIdentityOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(2, 3, 2.0);
+  A.matrix().set(2, 3, 2.f);
   EXPECT_TRUE(A.IsIdentityOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 3, 2.0);
+  A.matrix().set(3, 3, 2.f);
   EXPECT_FALSE(A.IsIdentityOrTranslation());
 }
 
@@ -2199,72 +2209,72 @@ TEST(XFormTest, verifyIsScaleOrTranslation) {
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(0, 0, 2.0);
+  A.matrix().set(0, 0, 2.f);
   EXPECT_TRUE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 0, 2.0);
+  A.matrix().set(1, 0, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 0, 2.0);
+  A.matrix().set(2, 0, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 0, 2.0);
+  A.matrix().set(3, 0, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(0, 1, 2.0);
+  A.matrix().set(0, 1, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(1, 1, 2.0);
+  A.matrix().set(1, 1, 2.f);
   EXPECT_TRUE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(2, 1, 2.0);
+  A.matrix().set(2, 1, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 1, 2.0);
+  A.matrix().set(3, 1, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(0, 2, 2.0);
+  A.matrix().set(0, 2, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(1, 2, 2.0);
+  A.matrix().set(1, 2, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(2, 2, 2.0);
+  A.matrix().set(2, 2, 2.f);
   EXPECT_TRUE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 2, 2.0);
+  A.matrix().set(3, 2, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(0, 3, 2.0);
+  A.matrix().set(0, 3, 2.f);
   EXPECT_TRUE(A.IsScaleOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(1, 3, 2.0);
+  A.matrix().set(1, 3, 2.f);
   EXPECT_TRUE(A.IsScaleOrTranslation());
 
   // Note carefully - expecting true here.
   A.MakeIdentity();
-  A.matrix().setDouble(2, 3, 2.0);
+  A.matrix().set(2, 3, 2.f);
   EXPECT_TRUE(A.IsScaleOrTranslation());
 
   A.MakeIdentity();
-  A.matrix().setDouble(3, 3, 2.0);
+  A.matrix().set(3, 3, 2.f);
   EXPECT_FALSE(A.IsScaleOrTranslation());
 }
 
@@ -2307,52 +2317,52 @@ static bool EmpiricallyPreserves2dAxisAlignment(const Transform& transform) {
 
 TEST(XFormTest, Preserves2dAxisAlignment) {
   static const struct TestCase {
-    double a; // row 1, column 1
-    double b; // row 1, column 2
-    double c; // row 2, column 1
-    double d; // row 2, column 2
+    SkMScalar a; // row 1, column 1
+    SkMScalar b; // row 1, column 2
+    SkMScalar c; // row 2, column 1
+    SkMScalar d; // row 2, column 2
     bool expected;
   } test_cases[] = {
-    { 3.0, 0.0,
-      0.0, 4.0, true }, // basic case
-    { 0.0, 4.0,
-      3.0, 0.0, true }, // rotate by 90
-    { 0.0, 0.0,
-      0.0, 4.0, true }, // degenerate x
-    { 3.0, 0.0,
-      0.0, 0.0, true }, // degenerate y
-    { 0.0, 0.0,
-      3.0, 0.0, true }, // degenerate x + rotate by 90
-    { 0.0, 4.0,
-      0.0, 0.0, true }, // degenerate y + rotate by 90
-    { 3.0, 4.0,
-      0.0, 0.0, false },
-    { 0.0, 0.0,
-      3.0, 4.0, false },
-    { 0.0, 3.0,
-      0.0, 4.0, false },
-    { 3.0, 0.0,
-      4.0, 0.0, false },
-    { 3.0, 4.0,
-      5.0, 0.0, false },
-    { 3.0, 4.0,
-      0.0, 5.0, false },
-    { 3.0, 0.0,
-      4.0, 5.0, false },
-    { 0.0, 3.0,
-      4.0, 5.0, false },
-    { 2.0, 3.0,
-      4.0, 5.0, false },
+    { 3.f, 0.f,
+      0.f, 4.f, true }, // basic case
+    { 0.f, 4.f,
+      3.f, 0.f, true }, // rotate by 90
+    { 0.f, 0.f,
+      0.f, 4.f, true }, // degenerate x
+    { 3.f, 0.f,
+      0.f, 0.f, true }, // degenerate y
+    { 0.f, 0.f,
+      3.f, 0.f, true }, // degenerate x + rotate by 90
+    { 0.f, 4.f,
+      0.f, 0.f, true }, // degenerate y + rotate by 90
+    { 3.f, 4.f,
+      0.f, 0.f, false },
+    { 0.f, 0.f,
+      3.f, 4.f, false },
+    { 0.f, 3.f,
+      0.f, 4.f, false },
+    { 3.f, 0.f,
+      4.f, 0.f, false },
+    { 3.f, 4.f,
+      5.f, 0.f, false },
+    { 3.f, 4.f,
+      0.f, 5.f, false },
+    { 3.f, 0.f,
+      4.f, 5.f, false },
+    { 0.f, 3.f,
+      4.f, 5.f, false },
+    { 2.f, 3.f,
+      4.f, 5.f, false },
   };
 
   Transform transform;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     transform.MakeIdentity();
-    transform.matrix().setDouble(0, 0, value.a);
-    transform.matrix().setDouble(0, 1, value.b);
-    transform.matrix().setDouble(1, 0, value.c);
-    transform.matrix().setDouble(1, 1, value.d);
+    transform.matrix().set(0, 0, value.a);
+    transform.matrix().set(0, 1, value.b);
+    transform.matrix().set(1, 0, value.c);
+    transform.matrix().set(1, 1, value.d);
 
     if (value.expected) {
       EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
@@ -2368,19 +2378,19 @@ TEST(XFormTest, Preserves2dAxisAlignment) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     transform.MakeIdentity();
-    transform.matrix().setDouble(0, 0, value.a);
-    transform.matrix().setDouble(0, 1, value.b);
-    transform.matrix().setDouble(1, 0, value.c);
-    transform.matrix().setDouble(1, 1, value.d);
-
-    transform.matrix().setDouble(0, 2, 1.0);
-    transform.matrix().setDouble(0, 3, 2.0);
-    transform.matrix().setDouble(1, 2, 3.0);
-    transform.matrix().setDouble(1, 3, 4.0);
-    transform.matrix().setDouble(2, 0, 5.0);
-    transform.matrix().setDouble(2, 1, 6.0);
-    transform.matrix().setDouble(2, 2, 7.0);
-    transform.matrix().setDouble(2, 3, 8.0);
+    transform.matrix().set(0, 0, value.a);
+    transform.matrix().set(0, 1, value.b);
+    transform.matrix().set(1, 0, value.c);
+    transform.matrix().set(1, 1, value.d);
+
+    transform.matrix().set(0, 2, 1.f);
+    transform.matrix().set(0, 3, 2.f);
+    transform.matrix().set(1, 2, 3.f);
+    transform.matrix().set(1, 3, 4.f);
+    transform.matrix().set(2, 0, 5.f);
+    transform.matrix().set(2, 1, 6.f);
+    transform.matrix().set(2, 2, 7.f);
+    transform.matrix().set(2, 3, 8.f);
 
     if (value.expected) {
       EXPECT_TRUE(EmpiricallyPreserves2dAxisAlignment(transform));
@@ -2396,23 +2406,23 @@ TEST(XFormTest, Preserves2dAxisAlignment) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
     const TestCase& value = test_cases[i];
     transform.MakeIdentity();
-    transform.matrix().setDouble(0, 0, value.a);
-    transform.matrix().setDouble(0, 1, value.b);
-    transform.matrix().setDouble(1, 0, value.c);
-    transform.matrix().setDouble(1, 1, value.d);
-
-    transform.matrix().setDouble(0, 2, 1.0);
-    transform.matrix().setDouble(0, 3, 2.0);
-    transform.matrix().setDouble(1, 2, 3.0);
-    transform.matrix().setDouble(1, 3, 4.0);
-    transform.matrix().setDouble(2, 0, 5.0);
-    transform.matrix().setDouble(2, 1, 6.0);
-    transform.matrix().setDouble(2, 2, 7.0);
-    transform.matrix().setDouble(2, 3, 8.0);
-    transform.matrix().setDouble(3, 0, 9.0);
-    transform.matrix().setDouble(3, 1, 10.0);
-    transform.matrix().setDouble(3, 2, 11.0);
-    transform.matrix().setDouble(3, 3, 12.0);
+    transform.matrix().set(0, 0, value.a);
+    transform.matrix().set(0, 1, value.b);
+    transform.matrix().set(1, 0, value.c);
+    transform.matrix().set(1, 1, value.d);
+
+    transform.matrix().set(0, 2, 1.f);
+    transform.matrix().set(0, 3, 2.f);
+    transform.matrix().set(1, 2, 3.f);
+    transform.matrix().set(1, 3, 4.f);
+    transform.matrix().set(2, 0, 5.f);
+    transform.matrix().set(2, 1, 6.f);
+    transform.matrix().set(2, 2, 7.f);
+    transform.matrix().set(2, 3, 8.f);
+    transform.matrix().set(3, 0, 9.f);
+    transform.matrix().set(3, 1, 10.f);
+    transform.matrix().set(3, 2, 11.f);
+    transform.matrix().set(3, 3, 12.f);
 
     EXPECT_FALSE(EmpiricallyPreserves2dAxisAlignment(transform));
     EXPECT_FALSE(transform.Preserves2dAxisAlignment());
diff --git a/ui/gfx/transform_util.cc b/ui/gfx/transform_util.cc
index 9bb3bbc..916b0b0 100644
--- a/ui/gfx/transform_util.cc
+++ b/ui/gfx/transform_util.cc
@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <cmath>
 
+#include "base/strings/stringprintf.h"
 #include "ui/gfx/point.h"
 
 namespace gfx {
@@ -14,7 +15,10 @@ namespace gfx {
 namespace {
 
 SkMScalar Length3(SkMScalar v[3]) {
-  return std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+  double vd[3] = {SkMScalarToDouble(v[0]), SkMScalarToDouble(v[1]),
+                  SkMScalarToDouble(v[2])};
+  return SkDoubleToMScalar(
+      std::sqrt(vd[0] * vd[0] + vd[1] * vd[1] + vd[2] * vd[2]));
 }
 
 void Scale3(SkMScalar v[3], SkMScalar scale) {
@@ -24,20 +28,20 @@ void Scale3(SkMScalar v[3], SkMScalar scale) {
 
 template <int n>
 SkMScalar Dot(const SkMScalar* a, const SkMScalar* b) {
-  SkMScalar toReturn = 0;
+  double total = 0.0;
   for (int i = 0; i < n; ++i)
-    toReturn += a[i] * b[i];
-  return toReturn;
+    total += a[i] * b[i];
+  return SkDoubleToMScalar(total);
 }
 
 template <int n>
 void Combine(SkMScalar* out,
              const SkMScalar* a,
              const SkMScalar* b,
-             SkMScalar scale_a,
-             SkMScalar scale_b) {
+             double scale_a,
+             double scale_b) {
   for (int i = 0; i < n; ++i)
-    out[i] = a[i] * scale_a + b[i] * scale_b;
+    out[i] = SkDoubleToMScalar(a[i] * scale_a + b[i] * scale_b);
 }
 
 void Cross3(SkMScalar out[3], SkMScalar a[3], SkMScalar b[3]) {
@@ -53,11 +57,11 @@ void Cross3(SkMScalar out[3], SkMScalar a[3], SkMScalar b[3]) {
 bool Slerp(SkMScalar out[4],
            const SkMScalar q1[4],
            const SkMScalar q2[4],
-           SkMScalar progress) {
-  SkMScalar product = Dot<4>(q1, q2);
+           double progress) {
+  double product = Dot<4>(q1, q2);
 
   // Clamp product to -1.0 <= product <= 1.0.
-  product = std::min(std::max(product, -SK_MScalar1), SK_MScalar1);
+  product = std::min(std::max(product, -1.0), 1.0);
 
   // Interpolate angles along the shortest path. For example, to interpolate
   // between a 175 degree angle and a 185 degree angle, interpolate along the
@@ -66,25 +70,25 @@ bool Slerp(SkMScalar out[4],
   // the current W3C spec. Fixing the spec to match this approach is discussed
   // at:
   // http://lists.w3.org/Archives/Public/www-style/2013May/0131.html
-  SkMScalar scale1 = SK_MScalar1;
+  double scale1 = 1.0;
   if (product < 0) {
     product = -product;
-    scale1 = -SK_MScalar1;
+    scale1 = -1.0;
   }
 
-  const SkMScalar epsilon = 1e-5;
-  if (std::abs(product - SK_MScalar1) < epsilon) {
+  const double epsilon = 1e-5;
+  if (std::abs(product - 1.0) < epsilon) {
     for (int i = 0; i < 4; ++i)
       out[i] = q1[i];
     return true;
   }
 
-  SkMScalar denom = std::sqrt(1 - product * product);
-  SkMScalar theta = std::acos(product);
-  SkMScalar w = std::sin(progress * theta) * (1 / denom);
+  double denom = std::sqrt(1.0 - product * product);
+  double theta = std::acos(product);
+  double w = std::sin(progress * theta) * (1.0 / denom);
 
   scale1 *= std::cos(progress * theta) - product * w;
-  SkMScalar scale2 = w;
+  double scale2 = w;
   Combine<4>(out, q1, q2, scale1, scale2);
 
   return true;
@@ -126,9 +130,9 @@ DecomposedTransform::DecomposedTransform() {
 bool BlendDecomposedTransforms(DecomposedTransform* out,
                                const DecomposedTransform& to,
                                const DecomposedTransform& from,
-                               SkMScalar progress) {
-  SkMScalar scalea = progress;
-  SkMScalar scaleb = SK_MScalar1 - progress;
+                               double progress) {
+  double scalea = progress;
+  double scaleb = 1.0 - progress;
   Combine<3>(out->translate, to.translate, from.translate, scalea, scaleb);
   Combine<3>(out->scale, to.scale, from.scale, scalea, scaleb);
   Combine<3>(out->skew, to.skew, from.skew, scalea, scaleb);
@@ -316,4 +320,30 @@ Transform ComposeTransform(const DecomposedTransform& decomp) {
   return to_return;
 }
 
+std::string DecomposedTransform::ToString() const {
+  return base::StringPrintf(
+      "translate: %+0.4f %+0.4f %+0.4f\n"
+      "scale: %+0.4f %+0.4f %+0.4f\n"
+      "skew: %+0.4f %+0.4f %+0.4f\n"
+      "perspective: %+0.4f %+0.4f %+0.4f %+0.4f\n"
+      "quaternion: %+0.4f %+0.4f %+0.4f %+0.4f\n",
+      translate[0],
+      translate[1],
+      translate[2],
+      scale[0],
+      scale[1],
+      scale[2],
+      skew[0],
+      skew[1],
+      skew[2],
+      perspective[0],
+      perspective[1],
+      perspective[2],
+      perspective[3],
+      quaternion[0],
+      quaternion[1],
+      quaternion[2],
+      quaternion[3]);
+}
+
 }  // namespace ui
diff --git a/ui/gfx/transform_util.h b/ui/gfx/transform_util.h
index be5ba4c..e5a2138 100644
--- a/ui/gfx/transform_util.h
+++ b/ui/gfx/transform_util.h
@@ -28,6 +28,8 @@ struct UI_EXPORT DecomposedTransform {
   SkMScalar perspective[4];
   SkMScalar quaternion[4];
 
+  std::string ToString() const;
+
   // Copy and assign are allowed.
 };
 
@@ -38,7 +40,7 @@ struct UI_EXPORT DecomposedTransform {
 UI_EXPORT bool BlendDecomposedTransforms(DecomposedTransform* out,
                                          const DecomposedTransform& to,
                                          const DecomposedTransform& from,
-                                         SkMScalar progress);
+                                         double progress);
 
 // Decomposes this transform into its translation, scale, skew, perspective,
 // and rotation components following the routines detailed in this spec:
diff --git a/ui/views/view_unittest.cc b/ui/views/view_unittest.cc
index ddee046..25ae690 100644
--- a/ui/views/view_unittest.cc
+++ b/ui/views/view_unittest.cc
@@ -1721,7 +1721,7 @@ TEST_F(ViewTest, TransformEvent) {
   // Now rotate |v2| inside |v1| clockwise.
   transform = v2->GetTransform();
   RotateClockwise(&transform);
-  transform.matrix().setDouble(0, 3, 100.0);
+  transform.matrix().set(0, 3, 100.f);
   v2->SetTransform(transform);
 
   // Now, |v2| occupies (100, 100) to (200, 300) in |v1|, and (100, 300) to
@@ -1751,13 +1751,13 @@ TEST_F(ViewTest, TransformEvent) {
   // Rotate |v3| clockwise with respect to |v2|.
   transform = v1->GetTransform();
   RotateClockwise(&transform);
-  transform.matrix().setDouble(0, 3, 30.0);
+  transform.matrix().set(0, 3, 30.f);
   v3->SetTransform(transform);
 
   // Scale |v2| with respect to |v1| along both axis.
   transform = v2->GetTransform();
-  transform.matrix().setDouble(0, 0, 0.8);
-  transform.matrix().setDouble(1, 1, 0.5);
+  transform.matrix().set(0, 0, 0.8f);
+  transform.matrix().set(1, 1, 0.5f);
   v2->SetTransform(transform);
 
   // |v3| occupies (108, 105) to (132, 115) in |root|.
@@ -1788,19 +1788,19 @@ TEST_F(ViewTest, TransformEvent) {
   // Rotate |v3| clockwise with respect to |v2|, and scale it along both axis.
   transform = v3->GetTransform();
   RotateClockwise(&transform);
-  transform.matrix().setDouble(0, 3, 30.0);
+  transform.matrix().set(0, 3, 30.f);
   // Rotation sets some scaling transformation. Using SetScale would overwrite
   // that and pollute the rotation. So combine the scaling with the existing
   // transforamtion.
   gfx::Transform scale;
-  scale.Scale(0.8, 0.5);
+  scale.Scale(0.8f, 0.5f);
   transform.ConcatTransform(scale);
   v3->SetTransform(transform);
 
   // Translate |v2| with respect to |v1|.
   transform = v2->GetTransform();
-  transform.matrix().setDouble(0, 3, 10.0);
-  transform.matrix().setDouble(1, 3, 10.0);
+  transform.matrix().set(0, 3, 10.f);
+  transform.matrix().set(1, 3, 10.f);
   v2->SetTransform(transform);
 
   // |v3| now occupies (120, 120) to (144, 130) in |root|.
@@ -1844,7 +1844,7 @@ TEST_F(ViewTest, TransformVisibleBound) {
   // Rotate |child| counter-clockwise
   gfx::Transform transform;
   RotateCounterclockwise(&transform);
-  transform.matrix().setDouble(1, 3, 50.0);
+  transform.matrix().set(1, 3, 50.f);
   child->SetTransform(transform);
   EXPECT_EQ(gfx::Rect(40, 0, 10, 50), child->GetVisibleBounds());
 
@@ -2079,7 +2079,7 @@ TEST_F(ViewTest, ConvertRectWithTransform) {
   // Rotate |v2|
   gfx::Transform t2;
   RotateCounterclockwise(&t2);
-  t2.matrix().setDouble(1, 3, 100.0);
+  t2.matrix().set(1, 3, 100.f);
   v2->SetTransform(t2);
 
   // |v2| now occupies (30, 30) to (230, 130) in |widget|
diff --git a/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc b/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
index 02a2ac3..dc0b434 100644
--- a/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
+++ b/webkit/renderer/compositor_bindings/web_layer_impl_fixed_bounds_unittest.cc
@@ -184,7 +184,7 @@ TEST(WebLayerImplFixedBoundsTest, CompareToWebLayerImplComplex) {
 
   gfx::Transform sublayer_transform;
   // These are arbitrary values that should not affect the results.
-  sublayer_transform.Scale3d(1.1, 2.2, 3.3);
+  sublayer_transform.Scale3d(1.1f, 2.2f, 3.3f);
   sublayer_transform.Translate3d(11, 22, 33);
   sublayer_transform.RotateAbout(gfx::Vector3dF(10, 30, 20), 88);