Converted LayerImpl::bounds() to return SizeF.

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 <set>
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/animation/transform_operations.h"
@@ skipping 12 matching lines @@
 #include "cc/test/fake_impl_proxy.h"
 #include "cc/test/fake_layer_tree_host.h"
 #include "cc/test/fake_layer_tree_host_impl.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/layer_tree_host_common_test.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/proxy.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/quad_f.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 namespace {
 
 class LayerWithForcedDrawsContent : public Layer {
  public:
   LayerWithForcedDrawsContent() {}
 
@@ skipping 1108 matching lines @@
                                gfx::PointF(),
                                gfx::Size(20, 20),
                                true,
                                false);
 
   gfx::Transform translate;
   translate.Translate(50, 50);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), translate, &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        translate,
+        &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
     EXPECT_EQ(translate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
   }
 
   gfx::Transform scale;
   scale.Scale(2, 2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), scale, &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        scale,
+        &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(scale, root->draw_properties().target_space_transform);
     EXPECT_EQ(scale, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(2.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(2.f, child->draw_properties().device_scale_factor);
   }
 
   gfx::Transform rotate;
   rotate.Rotate(2);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), rotate, &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        rotate,
+        &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(rotate, root->draw_properties().target_space_transform);
     EXPECT_EQ(rotate, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
   }
 
   gfx::Transform composite;
   composite.ConcatTransform(translate);
   composite.ConcatTransform(scale);
   composite.ConcatTransform(rotate);
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), composite, &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        composite,
+        &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     EXPECT_EQ(composite, root->draw_properties().target_space_transform);
     EXPECT_EQ(composite, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
 
   // Verify it composes correctly with device scale.
   float device_scale_factor = 1.5f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), translate, &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        translate,
+        &render_surface_layer_list);
     inputs.device_scale_factor = device_scale_factor;
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform device_scaled_translate = translate;
     device_scaled_translate.Scale(device_scale_factor, device_scale_factor);
     EXPECT_EQ(device_scaled_translate,
               root->draw_properties().target_space_transform);
     EXPECT_EQ(device_scaled_translate,
               child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(device_scale_factor, root->draw_properties().device_scale_factor);
     EXPECT_EQ(device_scale_factor,
               child->draw_properties().device_scale_factor);
   }
 
   // Verify it composes correctly with page scale.
   float page_scale_factor = 2.f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), translate, &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        translate,
+        &render_surface_layer_list);
     inputs.page_scale_factor = page_scale_factor;
     inputs.page_scale_application_layer = root.get();
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform page_scaled_translate = translate;
     page_scaled_translate.Scale(page_scale_factor, page_scale_factor);
     EXPECT_EQ(translate, root->draw_properties().target_space_transform);
     EXPECT_EQ(page_scaled_translate,
               child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
     EXPECT_EQ(1.f, root->draw_properties().device_scale_factor);
     EXPECT_EQ(1.f, child->draw_properties().device_scale_factor);
   }
 
   // Verify that it composes correctly with transforms directly on root layer.
   root->SetTransform(composite);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), composite, &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        composite,
+        &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
     gfx::Transform compositeSquared = composite;
     compositeSquared.ConcatTransform(composite);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, root->draw_properties().target_space_transform);
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         compositeSquared, child->draw_properties().target_space_transform);
     EXPECT_EQ(identity_matrix, root->render_surface()->draw_transform());
   }
@@ skipping 3188 matching lines @@
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(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,
@@ skipping 22 matching lines @@
   }
 
   // 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);
+        root.get(),
+        gfx::ToCeiledSize(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.
   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);
+        root.get(),
+        gfx::ToCeiledSize(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,
                              child_scale);
     EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                              child_empty);
     EXPECT_CONTENTS_SCALE_EQ(1, child_no_scale);
   }
 
   // If the device_scale_factor or page_scale_factor changes, then it should be
   // updated, but still using 1.0 as the raster scale.
   device_scale_factor = 2.75f;
   page_scale_factor = 1.75f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(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,
@@ skipping 67 matching lines @@
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 1.f;
 
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(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,
                            child_scale);
   EXPECT_CONTENTS_SCALE_EQ(device_scale_factor * page_scale_factor,
                            child_empty);
@@ skipping 61 matching lines @@
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(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);
     // 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();
   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);
+        root.get(),
+        gfx::ToCeiledSize(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 *
@@ skipping 100 matching lines @@
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   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);
+      root.get(),
+      gfx::ToCeiledSize(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,
@@ skipping 180 matching lines @@
   surface_no_scale->AddChild(surface_no_scale_child_no_scale);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
 
   SkMScalar device_scale_factor = 5.0;
   SkMScalar page_scale_factor = 7.0;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(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);
@@ skipping 124 matching lines @@
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   // Now put an animating transform on child.
   int animation_id = AddAnimatedTransformToController(
       child_scale->layer_animation_controller(), 10.0, 30, 0);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
     // The layers with animating transforms should not compute a contents scale
     // other than 1 until they finish animating.
     EXPECT_CONTENTS_SCALE_EQ(1, child_scale);
   }
 
   // Remove the animation, now it can save a raster scale.
   child_scale->layer_animation_controller()->RemoveAnimation(animation_id);
 
   {
     RenderSurfaceLayerList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     inputs.can_adjust_raster_scales = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale, parent);
     // The layers with animating transforms should not compute a contents scale
     // other than 1 until they finish animating.
     EXPECT_CONTENTS_SCALE_EQ(initial_parent_scale * initial_child_scale,
                              child_scale);
   }
 }
@@ skipping 390 matching lines @@
   child->SetOpacity(0.0f);
 
   // Add opacity animation.
   AddOpacityTransitionToController(
       child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false);
 
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The child
   // layer should be included even though it is transparent.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 }
 
 typedef std::tr1::tuple<bool, bool> LCDTextTestParam;
@@ skipping 189 matching lines @@
   grand_child->SetHideLayerAndSubtree(true);
 
   child->AddChild(grand_child);
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(child->id(), root->render_surface()->layer_list().at(1)->id());
 }
@@ skipping 35 matching lines @@
                                true,
                                false);
   grand_child->SetDrawsContent(true);
   grand_child->SetHideLayerAndSubtree(true);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and two layers. The grand child has
   // hidden itself.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(2u, root->render_surface()->layer_list().size());
   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
   EXPECT_EQ(2, root->render_surface()->layer_list().at(1)->id());
 }
@@ skipping 37 matching lines @@
   grand_child->SetIsDrawable(true);
 
   child->AddChild(grand_child);
   root->AddChild(child);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   EXPECT_EQ(root->id(), root->render_surface()->layer_list().at(0)->id());
 }
 
@@ skipping 34 matching lines @@
                                gfx::Size(30, 30),
                                true,
                                false);
   grand_child->SetDrawsContent(true);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.Pass());
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface and one layers. The child has
   // hidden itself and the grand child.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
   EXPECT_EQ(1, root->render_surface()->layer_list().at(0)->id());
 }
 
@@ skipping 91 matching lines @@
   // hidden subtree on copy_layer.
   copy_grand_parent->SetHideLayerAndSubtree(true);
   copy_grand_parent_sibling_before->SetHideLayerAndSubtree(true);
   copy_grand_parent_sibling_after->SetHideLayerAndSubtree(true);
   copy_layer->RequestCopyOfOutput(CopyOutputRequest::CreateRequest(
       base::Bind(&EmptyCopyOutputCallback)));
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_TRUE(root->draw_properties().layer_or_descendant_has_copy_request);
   EXPECT_TRUE(copy_grand_parent->draw_properties().
               layer_or_descendant_has_copy_request);
   EXPECT_TRUE(copy_parent->draw_properties().
               layer_or_descendant_has_copy_request);
   EXPECT_TRUE(copy_layer->draw_properties().
               layer_or_descendant_has_copy_request);
@@ skipping 88 matching lines @@
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   copy_layer->RequestCopyOfOutput(CopyOutputRequest::CreateRequest(
       base::Bind(&EmptyCopyOutputCallback)));
   EXPECT_TRUE(copy_layer->HasCopyRequest());
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // We should have one render surface, as the others are clipped out.
   ASSERT_EQ(1u, render_surface_layer_list.size());
   EXPECT_EQ(root->id(), render_surface_layer_list.at(0)->id());
 
   // The root render surface should only have 1 contributing layer, since the
   // other layers are empty/clipped away.
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
@@ skipping 39 matching lines @@
   surface_child->SetIsDrawable(true);
 
   surface->AddChild(surface_child);
   root->AddChild(surface);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // The visible_content_rect for the |surface_child| should not be clipped by
   // the viewport.
   EXPECT_EQ(gfx::Rect(50, 50).ToString(),
             surface_child->visible_content_rect().ToString());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformedClipParent) {
@@ skipping 608 matching lines @@
   child3->Set3dSortingContextId(1);
 
   child2->AddChild(child3.Pass());
   child1->AddChild(child2.Pass());
   root->AddChild(child1.Pass());
 
   {
     LayerImplList render_surface_layer_list;
     FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(root.get());
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     inputs.can_render_to_separate_surface = true;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(2u, render_surface_layer_list.size());
   }
 
   {
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     inputs.can_render_to_separate_surface = false;
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_EQ(1u, render_surface_layer_list.size());
   }
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotIncludeBackfaceInvisibleSurfaces) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<Layer> render_surface = Layer::Create();
@@ skipping 524 matching lines @@
                                gfx::Size(50, 50),
                                true,
                                false);
 
   scoped_ptr<FakeLayerTreeHost> host(CreateFakeLayerTreeHost());
   host->SetRootLayer(root);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       root.get(),
-      root->bounds(),
+      gfx::ToCeiledSize(root->bounds()),
       identity_transform,
       &render_surface_layer_list);
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_TRUE(root->render_surface());
 
   EXPECT_EQ(gfx::Rect(0, 0, 20, 20).ToString(),
             scroll_child->clip_rect().ToString());
   EXPECT_TRUE(scroll_child->is_clipped());
@@ skipping 115 matching lines @@
   scroll_child->AddChild(top_content.Pass());
   scroll_child->AddChild(bottom_content.Pass());
   root->AddChild(scroll_child.Pass());
 
   scroll_parent_clip->AddChild(scroll_parent.Pass());
   scroll_parent_border->AddChild(scroll_parent_clip.Pass());
   root->AddChild(scroll_parent_border.Pass());
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-      root.get(), root->bounds(), &render_surface_layer_list);
+      root.get(),
+      gfx::ToCeiledSize(root->bounds()),
+      &render_surface_layer_list);
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_TRUE(root->render_surface());
 
   // If we don't sort by depth and let the layers get added in the order they
   // would normally be visited in, then layers 6 and 7 will be out of order. In
   // other words, although we've had to shift 5, 6, and 7 to appear before 4
   // in the list (because of the scroll parent relationship), this should not
   // have an effect on the the order of 5, 6, and 7 (which had been reordered
@@ skipping 74 matching lines @@
   container->AddChild(scroller.Pass());
   root->AddChild(container.Pass());
 
   // Rounded to integers already.
   {
     gfx::Vector2dF scroll_delta(3.0, 5.0);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - scroll_delta);
   }
 
   // Scroll delta requiring rounding.
   {
     gfx::Vector2dF scroll_delta(4.1f, 8.1f);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     gfx::Vector2dF rounded_scroll_delta(4.f, 8.f);
 
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
     EXPECT_VECTOR_EQ(scroll_layer->draw_properties()
                          .screen_space_transform.To2dTranslation(),
                      container_offset - rounded_scroll_delta);
   }
 
   // Scale is applied earlier in the tree.
   {
     gfx::Transform scaled_container_transform = container_transform;
     scaled_container_transform.Scale3d(3.0, 3.0, 1.0);
     container_layer->SetTransform(scaled_container_transform);
 
     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         container_layer->draw_properties().screen_space_transform,
         fixed_layer->draw_properties().screen_space_transform);
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
 
     container_layer->SetTransform(container_transform);
   }
 
   // Scale is applied on the scroll layer itself.
   {
     gfx::Transform scale_transform;
     scale_transform.Scale3d(3.0, 3.0, 1.0);
     scroll_layer->SetTransform(scale_transform);
 
     gfx::Vector2dF scroll_delta(4.5f, 8.5f);
     scroll_layer->SetScrollDelta(scroll_delta);
 
     LayerImplList render_surface_layer_list;
     LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
-        root.get(), root->bounds(), &render_surface_layer_list);
+        root.get(),
+        gfx::ToCeiledSize(root->bounds()),
+        &render_surface_layer_list);
     LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
     EXPECT_VECTOR_EQ(
         fixed_layer->draw_properties().screen_space_transform.To2dTranslation(),
         container_offset);
 
     scroll_layer->SetTransform(identity_transform);
   }
 }
 
@@ skipping 792 matching lines @@
   // by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), root->visible_content_rect());
 
   // Layers drawing to a child render surface should still have their visible
   // content rect clipped by the viewport.
   EXPECT_EQ(gfx::Rect(768 / 2, 582 / 2), content->visible_content_rect());
 }
 
 }  // namespace
 }  // namespace cc