cc: Use SkMScalar instead of doubles everywhere in cc

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_common.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
@@ skipping 1354 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       A * B * A * B * A * S2,
       render_surface2->render_surface()->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       A * B * A * B * R * S2,
       render_surface2->render_surface()->replica_screen_space_transform());
 
   // Sanity check. If these fail there is probably a bug in the test itself.  It
   // is expected that we correctly set up transforms so that the y-component of
   // the screen-space transform encodes the "depth" of the layer in the tree.
-  EXPECT_FLOAT_EQ(1.0,
-                  parent->screen_space_transform().matrix().getDouble(1, 3));
+  EXPECT_FLOAT_EQ(1.0, parent->screen_space_transform().matrix().get(1, 3));
+  EXPECT_FLOAT_EQ(2.0,
+                  child_of_root->screen_space_transform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
-      2.0, child_of_root->screen_space_transform().matrix().getDouble(1, 3));
+      3.0, grand_child_of_root->screen_space_transform().matrix().get(1, 3));
+
+  EXPECT_FLOAT_EQ(2.0,
+                  render_surface1->screen_space_transform().matrix().get(1, 3));
+  EXPECT_FLOAT_EQ(3.0,
+                  child_of_rs1->screen_space_transform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
-      3.0,
-      grand_child_of_root->screen_space_transform().matrix().getDouble(1, 3));
+      4.0, grand_child_of_rs1->screen_space_transform().matrix().get(1, 3));
 
+  EXPECT_FLOAT_EQ(3.0,
+                  render_surface2->screen_space_transform().matrix().get(1, 3));
+  EXPECT_FLOAT_EQ(4.0,
+                  child_of_rs2->screen_space_transform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
-      2.0, render_surface1->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      3.0, child_of_rs1->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      4.0,
-      grand_child_of_rs1->screen_space_transform().matrix().getDouble(1, 3));
-
-  EXPECT_FLOAT_EQ(
-      3.0, render_surface2->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      4.0, child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      5.0,
-      grand_child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
+      5.0, grand_child_of_rs2->screen_space_transform().matrix().get(1, 3));
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformsForFlatteningLayer) {
   // For layers that flatten their subtree, there should be an orthographic
   // projection (for x and y values) in the middle of the transform sequence.
   // Note that the way the code is currently implemented, it is not expected to
   // use a canonical orthographic projection.
 
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
@@ skipping 249 matching lines @@
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), composite, &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     gfx::Transform compositeCubed = compositeSquared;
     compositeCubed.ConcatTransform(composite);
-    EXPECT_EQ(compositeSquared, root->draw_properties().target_space_transform);
-    EXPECT_EQ(compositeCubed, child->draw_properties().target_space_transform);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        compositeSquared, root->draw_properties().target_space_transform);
+    EXPECT_TRANSFORMATION_MATRIX_EQ(
+        compositeCubed, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceListForRenderSurfaceWithClippedLayer) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
@@ skipping 952 matching lines @@
   EXPECT_FALSE(grand_child_of_rs1->screen_space_transform_is_animating());
   EXPECT_TRUE(render_surface2->screen_space_transform_is_animating());
   EXPECT_TRUE(render_surface2->render_surface()
                   ->screen_space_transforms_are_animating());
   EXPECT_TRUE(child_of_rs2->screen_space_transform_is_animating());
   EXPECT_TRUE(grand_child_of_rs2->screen_space_transform_is_animating());
 
   // Sanity check. If these fail there is probably a bug in the test itself.
   // It is expected that we correctly set up transforms so that the y-component
   // of the screen-space transform encodes the "depth" of the layer in the tree.
-  EXPECT_FLOAT_EQ(1.0,
-                  parent->screen_space_transform().matrix().getDouble(1, 3));
+  EXPECT_FLOAT_EQ(1.0, parent->screen_space_transform().matrix().get(1, 3));
+  EXPECT_FLOAT_EQ(2.0,
+                  child_of_root->screen_space_transform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
-      2.0, child_of_root->screen_space_transform().matrix().getDouble(1, 3));
+      3.0, grand_child_of_root->screen_space_transform().matrix().get(1, 3));
+
+  EXPECT_FLOAT_EQ(2.0,
+                  render_surface1->screen_space_transform().matrix().get(1, 3));
+  EXPECT_FLOAT_EQ(3.0,
+                  child_of_rs1->screen_space_transform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
-      3.0,
-      grand_child_of_root->screen_space_transform().matrix().getDouble(1, 3));
+      4.0, grand_child_of_rs1->screen_space_transform().matrix().get(1, 3));
 
+  EXPECT_FLOAT_EQ(3.0,
+                  render_surface2->screen_space_transform().matrix().get(1, 3));
+  EXPECT_FLOAT_EQ(4.0,
+                  child_of_rs2->screen_space_transform().matrix().get(1, 3));
   EXPECT_FLOAT_EQ(
-      2.0, render_surface1->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      3.0, child_of_rs1->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      4.0,
-      grand_child_of_rs1->screen_space_transform().matrix().getDouble(1, 3));
-
-  EXPECT_FLOAT_EQ(
-      3.0, render_surface2->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      4.0, child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
-  EXPECT_FLOAT_EQ(
-      5.0,
-      grand_child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
+      5.0, grand_child_of_rs2->screen_space_transform().matrix().get(1, 3));
 }
 
 TEST_F(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
   // Test the calculateVisibleRect() function works correctly for identity
   // transforms.
 
   gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
   gfx::Transform layer_to_surface_transform;
 
   // Case 1: Layer is contained within the surface.
@@ skipping 115 matching lines @@
   layer_to_surface_transform.RotateAboutYAxis(45.0);
   gfx::Rect expected = gfx::Rect(0, 0, 100, 100);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 
   // Case 2: Orthographic projection of a layer rotated about y-axis by 45
   // degrees, but shifted to the side so only the right-half the layer would be
   // visible on the surface.
   // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
-  double half_width_of_rotated_layer = (100.0 / sqrt(2.0)) * 0.5;
+  SkMScalar half_width_of_rotated_layer = (100.0 / sqrt(2.0)) * 0.5;

[danakj, 2013/09/09 17:57:45]

should these be float literals? Or SkDoubleToMScalar?

[enne (OOO), 2013/09/10 22:32:32]

I'll do the latter.

   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(-half_width_of_rotated_layer, 0.0);
   layer_to_surface_transform.RotateAboutYAxis(45.0);  // Rotates about the left
                                                       // edge of the layer.
   expected = gfx::Rect(50, 0, 50, 100);  // Tight half of the layer.
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 }
 
@@ skipping 402 matching lines @@
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_TRUE(child->visible_content_rect().IsEmpty());
   EXPECT_TRUE(child->drawable_content_rect().IsEmpty());
 
   // Case 2: a matrix with flattened z, technically uninvertible but still
   // drawable and visible. In this case, we must assume that the entire layer
   // bounds are visible since there is no way to inverse-project the surface
   // bounds to intersect.
   uninvertible_matrix.MakeIdentity();
-  uninvertible_matrix.matrix().setDouble(2, 2, 0.0);
+  uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(child.get(),
                                uninvertible_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(5.f, 5.f),
                                gfx::Size(50, 50),
                                false);
 
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_RECT_EQ(gfx::Rect(0, 0, 50, 50), child->visible_content_rect());
   EXPECT_RECT_EQ(gfx::Rect(5, 5, 50, 50), child->drawable_content_rect());
 
   // Case 3: a matrix with flattened z, technically uninvertible but still
   // drawable, but not visible. In this case, we don't need to conservatively
   // assume that the whole layer is visible.
   uninvertible_matrix.MakeIdentity();
   uninvertible_matrix.Translate(500.0, 0.0);
-  uninvertible_matrix.matrix().setDouble(2, 2, 0.0);
+  uninvertible_matrix.matrix().set(2, 2, 0.0);
   ASSERT_FALSE(uninvertible_matrix.IsInvertible());
 
   SetLayerPropertiesForTesting(child.get(),
                                uninvertible_matrix,
                                identity_matrix,
                                gfx::PointF(),
                                gfx::PointF(5.f, 5.f),
                                gfx::Size(50, 50),
                                false);
 
@@ skipping 308 matching lines @@
                                false);
 
   root->SetMasksToBounds(true);
   render_surface1->SetForceRenderSurface(true);
   ExecuteCalculateDrawProperties(root.get());
 
   ASSERT_TRUE(render_surface1->render_surface());
 
   // The clipped surface clamps the DrawableContentRect that encloses the
   // rotated layer.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);

[danakj, 2013/09/09 17:57:45]

does it help if you use floats here?

[enne (OOO), 2013/09/10 22:32:32]

Sadly, sqrt(2) * 25 = 35.35, so it easily rounds up to 36 in both cases.

   gfx::Rect unclipped_surface_content = gfx::Rect(50.0 - diagonal_radius,

[danakj, 2013/09/09 17:57:45]

woa wierd, using double literals for an integer rect.

[enne (OOO), 2013/09/10 22:32:32]

Done.

                                                   50.0 - diagonal_radius,
                                                   diagonal_radius * 2.0,
                                                   diagonal_radius * 2.0);
   gfx::Rect expected_surface_drawable_content =
       gfx::IntersectRects(unclipped_surface_content, gfx::Rect(0, 0, 50, 50));
   EXPECT_RECT_EQ(expected_surface_drawable_content,
                  render_surface1->render_surface()->DrawableContentRect());
 
   // On the clipped surface, only a quarter  of the child1 is visible, but when
   // rotating it back to  child1's content space, the actual enclosing rect ends
   // up covering the full left half of child1.
+  //
+  // Given the floating point math, this number is a little bit fuzzy.
+#ifdef SK_MSCALAR_IS_DOUBLE

[enne (OOO), 2013/09/07 00:01:45]

This is the sketchiest part of this patch.  I'm not happy with this, but it's
less clear how to fix this to work both ways.

+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 25, 50), child1->visible_content_rect());
+#else
   EXPECT_RECT_EQ(gfx::Rect(0, 0, 26, 50), child1->visible_content_rect());
+#endif
 
   // The child's DrawableContentRect is unclipped.
   EXPECT_RECT_EQ(unclipped_surface_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsInHighDPI) {
   MockContentLayerClient client;
 
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<ContentLayer> render_surface1 =
@@ skipping 865 matching lines @@
   EXPECT_EQ(12345, result_layer->id());
 }
 
 TEST_F(LayerTreeHostCommonTest, HitTestingForUninvertibleTransform) {
   FakeImplProxy proxy;
   FakeLayerTreeHostImpl host_impl(&proxy);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform uninvertible_transform;
-  uninvertible_transform.matrix().setDouble(0, 0, 0.0);
-  uninvertible_transform.matrix().setDouble(1, 1, 0.0);
-  uninvertible_transform.matrix().setDouble(2, 2, 0.0);
-  uninvertible_transform.matrix().setDouble(3, 3, 0.0);
+  uninvertible_transform.matrix().set(0, 0, 0.0);
+  uninvertible_transform.matrix().set(1, 1, 0.0);
+  uninvertible_transform.matrix().set(2, 2, 0.0);
+  uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
   gfx::Transform identity_matrix;
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
                                identity_matrix,
                                anchor,
@@ skipping 562 matching lines @@
 
   // (11, 50) is inside the layer and within the clipped area.
   test_point = gfx::Point(11, 50);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
   EXPECT_EQ(2468, result_layer->id());
 
   // Around the middle, just to the right and up, would have hit the layer
   // except that that area should be clipped away by the parent.
-  test_point = gfx::Point(51, 51);
+  test_point = gfx::Point(51, 49);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
 
   // Around the middle, just to the left and down, should successfully hit the
   // layer.
   test_point = gfx::Point(49, 51);
   result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   ASSERT_TRUE(result_layer);
@@ skipping 492 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest,
      HitCheckingTouchHandlerRegionsForUninvertibleTransform) {
   FakeImplProxy proxy;
   FakeLayerTreeHostImpl host_impl(&proxy);
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl.active_tree(), 12345);
 
   gfx::Transform uninvertible_transform;
-  uninvertible_transform.matrix().setDouble(0, 0, 0.0);
-  uninvertible_transform.matrix().setDouble(1, 1, 0.0);
-  uninvertible_transform.matrix().setDouble(2, 2, 0.0);
-  uninvertible_transform.matrix().setDouble(3, 3, 0.0);
+  uninvertible_transform.matrix().set(0, 0, 0.0);
+  uninvertible_transform.matrix().set(1, 1, 0.0);
+  uninvertible_transform.matrix().set(2, 2, 0.0);
+  uninvertible_transform.matrix().set(3, 3, 0.0);
   ASSERT_FALSE(uninvertible_transform.IsInvertible());
 
   gfx::Transform identity_matrix;
   Region touch_handler_region(gfx::Rect(10, 10, 50, 50));
   gfx::PointF anchor;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
   SetLayerPropertiesForTesting(root.get(),
                                uninvertible_transform,
                                identity_matrix,
@@ skipping 879 matching lines @@
                                   child_no_scale->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_no_scale_transform,
                                   child_no_scale->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, ContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
-  double initial_parent_scale = 1.75;
+  SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
-  double initial_child_scale = 1.25;
+  SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                identity_matrix,
                                gfx::PointF(),
@@ skipping 60 matching lines @@
                              child_scale);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale * initial_child_scale,
                              child_empty);
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
 
     // The parent is scaled up and shouldn't need to scale during draw. The
     // child that can scale its contents should also not need to scale during
     // draw. This shouldn't change if the child has empty bounds. The other
     // children should.
-    EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(0, 0));
-    EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(1, 1));
-    EXPECT_FLOAT_EQ(1.0,
-                    child_scale->draw_transform().matrix().getDouble(0, 0));
-    EXPECT_FLOAT_EQ(1.0,
-                    child_scale->draw_transform().matrix().getDouble(1, 1));
-    EXPECT_FLOAT_EQ(1.0,
-                    child_empty->draw_transform().matrix().getDouble(0, 0));
-    EXPECT_FLOAT_EQ(1.0,
-                    child_empty->draw_transform().matrix().getDouble(1, 1));
+    EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(0, 0));
+    EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(1, 1));
+    EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().get(0, 0));
+    EXPECT_FLOAT_EQ(1.0, child_scale->draw_transform().matrix().get(1, 1));
+    EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().get(0, 0));
+    EXPECT_FLOAT_EQ(1.0, child_empty->draw_transform().matrix().get(1, 1));
     EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
                         initial_parent_scale * initial_child_scale,
-                    child_no_scale->draw_transform().matrix().getDouble(0, 0));
+                    child_no_scale->draw_transform().matrix().get(0, 0));
     EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
-                    initial_parent_scale * initial_child_scale,
-                    child_no_scale->draw_transform().matrix().getDouble(1, 1));
+                        initial_parent_scale * initial_child_scale,
+                    child_no_scale->draw_transform().matrix().get(1, 1));
   }
 
   // If the device_scale_factor or page_scale_factor changes, then it should be
   // updated using the initial transform as the raster scale.
   device_scale_factor = 2.25f;
   page_scale_factor = 1.25f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(
         device_scale_factor * page_scale_factor * initial_parent_scale, parent);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                                  initial_parent_scale * initial_child_scale,
                              child_scale);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale * initial_child_scale,
                              child_empty);
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
   }
 
   // If the transform changes, we expect the raster scale to be reset to 1.0.
-  double second_child_scale = 1.75;
+  SkMScalar second_child_scale = 1.75;
   child_scale_matrix.Scale(second_child_scale / initial_child_scale,
                            second_child_scale / initial_child_scale);
   child_scale->SetTransform(child_scale_matrix);
   child_empty->SetTransform(child_scale_matrix);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
@@ skipping 37 matching lines @@
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
   }
 }
 
 TEST_F(LayerTreeHostCommonTest,
      ContentsScale_LayerTransformsDontAffectContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
-  double initial_parent_scale = 1.75;
+  SkMScalar initial_parent_scale = 1.75;

[enne (OOO), 2013/09/07 00:01:45]

The best part of this patch is that there's no style guide for SkMScalar, so I
feel like we can ignore the style guide rule for literals.  Is it a float? Is it
a double? Who knows!

[danakj, 2013/09/09 17:57:45]

`On 2013/09/07 00:01:45, enne wrote:
Ya but I'm worried we'll end up with using all of them and we'll be like "what's
going on!??!" at some point. I wonder if we should be using float everywhere for
them?

[enne (OOO), 2013/09/10 22:32:32]

I wasn't totally serious here.  I think the plan should be that we  use floats
for SkMScalar for new code, but don't worry too hard about old code assigning
doubles to SkMScalars.

When I switch transforms to floats, I think there will likely be some narrowing
conversion errors that I'll have to fix, but I don't think it's worth the
trouble to change every SkMScalar literal to be a float as well.

   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
-  double initial_child_scale = 1.25;
+  SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                identity_matrix,
                                gfx::PointF(),
@@ skipping 55 matching lines @@
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            child_scale);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            child_empty);
   EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
 
   // Since the transform scale does not affect contents scale, it should affect
   // the draw transform instead.
   EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().getDouble(0, 0));
+                  parent->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().getDouble(1, 1));
+                  parent->draw_transform().matrix().get(1, 1));
   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
-                  child_scale->draw_transform().matrix().getDouble(0, 0));
+                  child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
-                  child_scale->draw_transform().matrix().getDouble(1, 1));
+                  child_scale->draw_transform().matrix().get(1, 1));
   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
-                  child_empty->draw_transform().matrix().getDouble(0, 0));
+                  child_empty->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(initial_parent_scale * initial_child_scale,
-                  child_empty->draw_transform().matrix().getDouble(1, 1));
+                  child_empty->draw_transform().matrix().get(1, 1));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
-                  initial_parent_scale * initial_child_scale,
-                  child_no_scale->draw_transform().matrix().getDouble(0, 0));
+                      initial_parent_scale * initial_child_scale,
+                  child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
-                  initial_parent_scale * initial_child_scale,
-                  child_no_scale->draw_transform().matrix().getDouble(1, 1));
+                      initial_parent_scale * initial_child_scale,
+                  child_no_scale->draw_transform().matrix().get(1, 1));
 }
 
 TEST_F(LayerTreeHostCommonTest, SmallContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
-  double initial_parent_scale = 1.75;
+  SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
-  double initial_child_scale = 0.25;
+  SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                identity_matrix,
                                gfx::PointF(),
@@ skipping 36 matching lines @@
                              parent);
     // The child's scale is < 1, so we should not save and use that scale
     // factor.
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor * 1,
                              child_scale);
   }
 
   // When chilld's total scale becomes >= 1, we should save and use that scale
   // factor.
   child_scale_matrix.MakeIdentity();
-  double final_child_scale = 0.75;
+  SkMScalar final_child_scale = 0.75;
   child_scale_matrix.Scale(final_child_scale, final_child_scale);
   child_scale->SetTransform(child_scale_matrix);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
         root.get(), root->bounds(), &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale,
                              parent);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                              initial_parent_scale * final_child_scale,
                              child_scale);
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, ContentsScaleForSurfaces) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
-  double initial_parent_scale = 2.0;
+  SkMScalar initial_parent_scale = 2.0;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
-  double initial_child_scale = 3.0;
+  SkMScalar initial_child_scale = 3.0;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                identity_matrix,
                                gfx::PointF(),
@@ skipping 70 matching lines @@
   surface_scale->AddChild(surface_scale_child_scale);
   surface_scale->AddChild(surface_scale_child_no_scale);
 
   surface_no_scale->SetForceRenderSurface(true);
   surface_no_scale->AddChild(surface_no_scale_child_scale);
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
-  double device_scale_factor = 5;
-  double page_scale_factor = 7;
+  SkMScalar device_scale_factor = 5;
+  SkMScalar page_scale_factor = 7;
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = root.get();
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_CONTENTS_SCALE_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale, parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor *
                                initial_parent_scale * initial_child_scale,
                            surface_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale);
   EXPECT_CONTENTS_SCALE_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
       initial_child_scale * initial_child_scale,
       surface_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_scale_child_no_scale);
   EXPECT_CONTENTS_SCALE_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
       initial_child_scale * initial_child_scale,
       surface_no_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1, surface_no_scale_child_no_scale);
 
   // The parent is scaled up and shouldn't need to scale during draw.
-  EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(0, 0));
-  EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().getDouble(1, 1));
+  EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(1.0, parent->draw_transform().matrix().get(1, 1));
 
   // RenderSurfaces should always be 1:1 with their target.
   EXPECT_FLOAT_EQ(
       1.0,
-      surface_scale->render_surface()->draw_transform().matrix().getDouble(0,
-                                                                           0));
+      surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       1.0,
-      surface_scale->render_surface()->draw_transform().matrix().getDouble(1,
-                                                                           1));
+      surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
 
   // The surface_scale can apply contents scale so the layer shouldn't need to
   // scale during draw.
-  EXPECT_FLOAT_EQ(1.0,
-                  surface_scale->draw_transform().matrix().getDouble(0, 0));
-  EXPECT_FLOAT_EQ(1.0,
-                  surface_scale->draw_transform().matrix().getDouble(1, 1));
+  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_scale can apply contents scale so it shouldn't need
   // to scale during draw.
   EXPECT_FLOAT_EQ(
-      1.0,
-      surface_scale_child_scale->draw_transform().matrix().getDouble(0, 0));
+      1.0, surface_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      1.0,
-      surface_scale_child_scale->draw_transform().matrix().getDouble(1, 1));
+      1.0, surface_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_no_scale can not apply contents scale, so it needs
   // to be scaled during draw.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
-      initial_child_scale * initial_child_scale,
-      surface_scale_child_no_scale->draw_transform().matrix().getDouble(0, 0));
+          initial_child_scale * initial_child_scale,
+      surface_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
-      initial_child_scale * initial_child_scale,
-      surface_scale_child_no_scale->draw_transform().matrix().getDouble(1, 1));
+          initial_child_scale * initial_child_scale,
+      surface_scale_child_no_scale->draw_transform().matrix().get(1, 1));
 
   // RenderSurfaces should always be 1:1 with their target.
   EXPECT_FLOAT_EQ(
       1.0,
-      surface_no_scale->render_surface()->draw_transform().matrix().getDouble(
-          0, 0));
+      surface_no_scale->render_surface()->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       1.0,
-      surface_no_scale->render_surface()->draw_transform().matrix().getDouble(
-          1, 1));
+      surface_no_scale->render_surface()->draw_transform().matrix().get(1, 1));
 
   // The surface_no_scale layer can not apply contents scale, so it needs to be
   // scaled during draw.
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
-                  initial_parent_scale * initial_child_scale,
-                  surface_no_scale->draw_transform().matrix().getDouble(0, 0));
+                      initial_parent_scale * initial_child_scale,
+                  surface_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor *
-                  initial_parent_scale * initial_child_scale,
-                  surface_no_scale->draw_transform().matrix().getDouble(1, 1));
+                      initial_parent_scale * initial_child_scale,
+                  surface_no_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_scale can apply contents scale so it shouldn't need
   // to scale during draw.
   EXPECT_FLOAT_EQ(
-      1.0,
-      surface_no_scale_child_scale->draw_transform().matrix().getDouble(0, 0));
+      1.0, surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
-      1.0,
-      surface_no_scale_child_scale->draw_transform().matrix().getDouble(1, 1));
+      1.0, surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_no_scale can not apply contents scale, so it needs
   // to be scaled during draw.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
-      initial_child_scale * initial_child_scale,
-      surface_no_scale_child_no_scale->draw_transform().matrix().getDouble(0,
-                                                                           0));
+          initial_child_scale * initial_child_scale,
+      surface_no_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_parent_scale *
-      initial_child_scale * initial_child_scale,
-      surface_no_scale_child_no_scale->draw_transform().matrix().getDouble(1,
-                                                                           1));
+          initial_child_scale * initial_child_scale,
+      surface_no_scale_child_no_scale->draw_transform().matrix().get(1, 1));
 }
 
 TEST_F(LayerTreeHostCommonTest,
      ContentsScaleForSurfaces_LayerTransformsDontAffectContentsScale) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
-  double initial_parent_scale = 2.0;
+  SkMScalar initial_parent_scale = 2.0;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
-  double initial_child_scale = 3.0;
+  SkMScalar initial_child_scale = 3.0;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                identity_matrix,
                                gfx::PointF(),
@@ skipping 72 matching lines @@
 
   surface_no_scale->SetForceRenderSurface(true);
   surface_no_scale->AddChild(surface_no_scale_child_scale);
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
   scoped_ptr<FakeLayerTreeHost> host = FakeLayerTreeHost::Create();
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
-  double device_scale_factor = 5.0;
-  double page_scale_factor = 7.0;
+  SkMScalar device_scale_factor = 5.0;
+  SkMScalar page_scale_factor = 7.0;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(), root->bounds(), &render_surface_layer_list);
   inputs.device_scale_factor = device_scale_factor;
   inputs.page_scale_factor = page_scale_factor;
   inputs.page_scale_application_layer = root.get();
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            parent);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            surface_scale);
   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_no_scale);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            surface_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_scale_child_no_scale);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            surface_no_scale_child_scale);
   EXPECT_CONTENTS_SCALE_EQ(1.f, surface_no_scale_child_no_scale);
 
   // The parent is scaled up during draw, since its contents are not scaled by
   // the transform hierarchy.
   EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().getDouble(0, 0));
+                  parent->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(initial_parent_scale,
-                  parent->draw_transform().matrix().getDouble(1, 1));
+                  parent->draw_transform().matrix().get(1, 1));
 
   // The child surface is scaled up during draw since its subtree is not scaled
   // by the transform hierarchy.
   EXPECT_FLOAT_EQ(
       initial_parent_scale * initial_child_scale,
-      surface_scale->render_surface()->draw_transform().matrix().getDouble(0,
-                                                                           0));
+      surface_scale->render_surface()->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       initial_parent_scale * initial_child_scale,
-      surface_scale->render_surface()->draw_transform().matrix().getDouble(1,
-                                                                           1));
+      surface_scale->render_surface()->draw_transform().matrix().get(1, 1));
 
   // The surface_scale's RenderSurface is scaled during draw, so the layer does
   // not need to be scaled when drawing into its surface.
-  EXPECT_FLOAT_EQ(1.0,
-                  surface_scale->draw_transform().matrix().getDouble(0, 0));
-  EXPECT_FLOAT_EQ(1.0,
-                  surface_scale->draw_transform().matrix().getDouble(1, 1));
+  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(0, 0));
+  EXPECT_FLOAT_EQ(1.0, surface_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_scale is scaled when drawing into its surface,
   // since its content bounds are not scaled by the transform hierarchy.
   EXPECT_FLOAT_EQ(
       initial_child_scale,
-      surface_scale_child_scale->draw_transform().matrix().getDouble(0, 0));
+      surface_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       initial_child_scale,
-      surface_scale_child_scale->draw_transform().matrix().getDouble(1, 1));
+      surface_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_scale_child_no_scale has a fixed contents scale of 1, so it
   // needs to be scaled by the device and page scale factors, along with the
   // transform hierarchy.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
-      surface_scale_child_no_scale->draw_transform().matrix().getDouble(0, 0));
+      surface_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
-      surface_scale_child_no_scale->draw_transform().matrix().getDouble(1, 1));
+      surface_scale_child_no_scale->draw_transform().matrix().get(1, 1));
 
   // The child surface is scaled up during draw since its subtree is not scaled
   // by the transform hierarchy.
   EXPECT_FLOAT_EQ(
       initial_parent_scale * initial_child_scale,
-      surface_no_scale->render_surface()->draw_transform().matrix().getDouble(
-          0, 0));
+      surface_no_scale->render_surface()->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       initial_parent_scale * initial_child_scale,
-      surface_no_scale->render_surface()->draw_transform().matrix().getDouble(
-          1, 1));
+      surface_no_scale->render_surface()->draw_transform().matrix().get(1, 1));
 
   // The surface_no_scale layer has a fixed contents scale of 1, so it needs to
   // be scaled by the device and page scale factors. Its surface is already
   // scaled by the transform hierarchy so those don't need to scale the layer's
   // drawing.
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
-                  surface_no_scale->draw_transform().matrix().getDouble(0, 0));
+                  surface_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(device_scale_factor * page_scale_factor,
-                  surface_no_scale->draw_transform().matrix().getDouble(1, 1));
+                  surface_no_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_no_scale_child_scale has its contents scaled by the page and
   // device scale factors, but needs to be scaled by the transform hierarchy
   // when drawing.
   EXPECT_FLOAT_EQ(
       initial_child_scale,
-      surface_no_scale_child_scale->draw_transform().matrix().getDouble(0, 0));
+      surface_no_scale_child_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       initial_child_scale,
-      surface_no_scale_child_scale->draw_transform().matrix().getDouble(1, 1));
+      surface_no_scale_child_scale->draw_transform().matrix().get(1, 1));
 
   // The surface_no_scale_child_no_scale has a fixed contents scale of 1, so it
   // needs to be scaled by the device and page scale factors. It also needs to
   // be scaled by any transform heirarchy below its target surface.
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
-      surface_no_scale_child_no_scale->draw_transform().matrix().getDouble(0,
-                                                                           0));
+      surface_no_scale_child_no_scale->draw_transform().matrix().get(0, 0));
   EXPECT_FLOAT_EQ(
       device_scale_factor * page_scale_factor * initial_child_scale,
-      surface_no_scale_child_no_scale->draw_transform().matrix().getDouble(1,
-                                                                           1));
+      surface_no_scale_child_no_scale->draw_transform().matrix().get(1, 1));
 }
 
 TEST_F(LayerTreeHostCommonTest, ContentsScaleForAnimatingLayer) {
   MockContentLayerClient delegate;
   gfx::Transform identity_matrix;
 
   gfx::Transform parent_scale_matrix;
-  double initial_parent_scale = 1.75;
+  SkMScalar initial_parent_scale = 1.75;
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
-  double initial_child_scale = 1.25;
+  SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   scoped_refptr<Layer> root = Layer::Create();
   root->SetBounds(gfx::Size(100, 100));
 
   scoped_refptr<ContentLayer> parent = CreateDrawableContentLayer(&delegate);
   SetLayerPropertiesForTesting(parent.get(),
                                parent_scale_matrix,
                                identity_matrix,
                                gfx::PointF(),
@@ skipping 161 matching lines @@
                                   child->render_surface()->draw_transform());
 
   gfx::Transform expected_surface_screen_space_transform;
   expected_surface_screen_space_transform.Translate(device_scale_factor * 2.f,
                                                     device_scale_factor * 2.f);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_screen_space_transform,
       child->render_surface()->screen_space_transform());
 
   gfx::Transform expected_replica_draw_transform;
-  expected_replica_draw_transform.matrix().setDouble(1, 1, -1.0);
-  expected_replica_draw_transform.matrix().setDouble(0, 3, 6.0);
-  expected_replica_draw_transform.matrix().setDouble(1, 3, 6.0);
+  expected_replica_draw_transform.matrix().set(1, 1, -1.0);
+  expected_replica_draw_transform.matrix().set(0, 3, 6.0);
+  expected_replica_draw_transform.matrix().set(1, 3, 6.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_draw_transform,
       child->render_surface()->replica_draw_transform());
 
   gfx::Transform expected_replica_screen_space_transform;
-  expected_replica_screen_space_transform.matrix().setDouble(1, 1, -1.0);
-  expected_replica_screen_space_transform.matrix().setDouble(0, 3, 6.0);
-  expected_replica_screen_space_transform.matrix().setDouble(1, 3, 6.0);
+  expected_replica_screen_space_transform.matrix().set(1, 1, -1.0);
+  expected_replica_screen_space_transform.matrix().set(0, 3, 6.0);
+  expected_replica_screen_space_transform.matrix().set(1, 3, 6.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest,
      RenderSurfaceTransformsInHighDPIAccurateScaleZeroPosition) {
@@ skipping 79 matching lines @@
             duplicate_child_non_owner->content_bounds());
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_transform,
                                   child->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       identity_transform, child->render_surface()->screen_space_transform());
 
   gfx::Transform expected_replica_draw_transform;
-  expected_replica_draw_transform.matrix().setDouble(1, 1, -1.0);
+  expected_replica_draw_transform.matrix().set(1, 1, -1.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_draw_transform,
       child->render_surface()->replica_draw_transform());
 
   gfx::Transform expected_replica_screen_space_transform;
-  expected_replica_screen_space_transform.matrix().setDouble(1, 1, -1.0);
+  expected_replica_screen_space_transform.matrix().set(1, 1, -1.0);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_replica_screen_space_transform,
       child->render_surface()->replica_screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeSearch) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> child = Layer::Create();
   scoped_refptr<Layer> grand_child = Layer::Create();
   scoped_refptr<Layer> mask_layer = Layer::Create();
@@ skipping 1377 matching lines @@
   ExecuteCalculateDrawProperties(root.get());
 
   EXPECT_EQ(1u, render_surface_layer_list()->size());
   EXPECT_EQ(0u,
             render_surface_layer_list()->at(0)
                 ->render_surface()->layer_list().size());
 }
 
 }  // namespace
 }  // namespace cc