Fix some unit tests that fail when we enable impl property trees

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 <algorithm>
 #include <set>
 
 #include "cc/animation/keyframed_animation_curve.h"
@@ skipping 128 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(identity_matrix,
                                   grand_child->screen_space_transform());
 }
 
 TEST_F(LayerTreeHostCommonTest, DoNotSkipLayersWithHandlers) {
   LayerImpl* parent = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
+  child->SetDrawsContent(true);
+  grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(10, 10), gfx::Size(100, 100), true,
                                false, false);
   // This would have previously caused us to skip our subtree, but this would be
   // wrong; we need up-to-date draw properties to do hit testing on the layers
@@ skipping 302 matching lines @@
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(1, 2), true, false,
                                true);
 
   // Child is set up so that a new render surface should be created.
   child->SetOpacity(0.5f);
+  child->SetDrawsContent(true);
 
   gfx::Transform parent_layer_transform;
   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_composite_transform =
       parent_translation_to_anchor * parent_layer_transform *
       Inverse(parent_translation_to_anchor);
   gfx::Vector2dF parent_composite_scale =
@@ skipping 174 matching lines @@
   //   have a draw transform described w.r.t. that ancestor surface
   //   - Replicas of a render surface are described w.r.t. the replica's
   //   transform around its anchor, along with the surface itself.
   //   - Sanity check on recursion: verify transforms of layers described w.r.t.
   //   a render surface that is described w.r.t. an ancestor render surface.
   //   - verifying that each layer has a reference to the correct render surface
   //   and render target values.
 
   LayerImpl* root = root_layer();
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  parent->SetDrawsContent(true);
   LayerImpl* render_surface1 = AddChild<LayerImpl>(parent);
+  render_surface1->SetDrawsContent(true);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
+  render_surface2->SetDrawsContent(true);
   LayerImpl* child_of_root = AddChild<LayerImpl>(parent);
+  child_of_root->SetDrawsContent(true);
   LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1);
+  child_of_rs1->SetDrawsContent(true);
   LayerImpl* child_of_rs2 = AddChild<LayerImpl>(render_surface2);
+  child_of_rs2->SetDrawsContent(true);
   LayerImpl* grand_child_of_root = AddChild<LayerImpl>(child_of_root);
+  grand_child_of_root->SetDrawsContent(true);
   LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1);
   grand_child_of_rs1->SetDrawsContent(true);
   LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2);
   grand_child_of_rs2->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> replica_of_rs1 =
       LayerImpl::Create(host_impl()->active_tree(), 101);
   scoped_ptr<LayerImpl> replica_of_rs2 =
       LayerImpl::Create(host_impl()->active_tree(), 102);
 
@@ skipping 203 matching lines @@
 }
 
 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.
 
   LayerImpl* root = root_layer();
   LayerImpl* child = AddChildToRoot<LayerImpl>();
+  child->SetDrawsContent(true);
   LayerImpl* grand_child = AddChild<LayerImpl>(child);
   grand_child->SetDrawsContent(true);
   LayerImpl* great_grand_child = AddChild<LayerImpl>(grand_child);
   great_grand_child->SetDrawsContent(true);
 
   gfx::Transform rotation_about_y_axis;
   rotation_about_y_axis.RotateAboutYAxis(30.0);
 
   const gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
@@ skipping 344 matching lines @@
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       parent, parent->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   // The layer is fully transparent, but has a background filter, so it
   // shouldn't be skipped.
   ASSERT_TRUE(parent->render_surface());
   EXPECT_EQ(1U, parent->render_surface()->layer_list().size());
   EXPECT_EQ(2U, render_surface_layer_list.size());
-  EXPECT_EQ(gfx::Rect(0, 0, 10, 10), parent->drawable_content_rect());

[ajuma, 2015/11/09 23:17:19]

Just to make sure, is this line removed because making the parent draw content
(causing it to have draw properties computed) would change the scenario this is
trying to test? Can we instead check the root render surface's drawable content
rect?

[jaydasika, 2015/11/09 23:27:58]

Yes, making parent draw content will change what this test is trying to test.
And yes, we can check the surface's drawable content rect. 

 }
 
 TEST_F(LayerTreeHostCommonTest, RenderSurfaceForBlendMode) {
   LayerImpl* parent = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   child->SetDrawsContent(true);
 
   const gfx::Transform identity_matrix;
   const SkXfermode::Mode blend_mode = SkXfermode::kMultiply_Mode;
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
@@ skipping 338 matching lines @@
   //
   // In particular, for a layer that owns a render surface:
   //  - the render surface inherits any clip from ancestors, and does NOT
   //    pass that clipped status to the layer itself.
   //  - but if the layer itself masks to bounds, it is considered clipped
   //    and propagates the clip to the subtree.
 
   const gfx::Transform identity_matrix;
   LayerImpl* root = root_layer();
   LayerImpl* parent = AddChild<LayerImpl>(root);
+  parent->SetDrawsContent(true);
   LayerImpl* child1 = AddChild<LayerImpl>(parent);
+  child1->SetDrawsContent(true);
   LayerImpl* child2 = AddChild<LayerImpl>(parent);
+  child2->SetDrawsContent(true);
   LayerImpl* grand_child = AddChild<LayerImpl>(child1);
+  grand_child->SetDrawsContent(true);
   LayerImpl* leaf_node1 = AddChild<LayerImpl>(grand_child);
   leaf_node1->SetDrawsContent(true);
   LayerImpl* leaf_node2 = AddChild<LayerImpl>(child2);
   leaf_node2->SetDrawsContent(true);
 
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
@@ skipping 256 matching lines @@
   //   grand_child3 - partially clipped and masksToBounds; the
   //   DrawableContentRect will still be the intersection of layer bounds and
   //   the mask region.
   //   grand_child4 - outside parent's clip rect; the DrawableContentRect should
   //   be empty.
 
   const gfx::Transform identity_matrix;
   LayerImpl* parent = root_layer();
   LayerImpl* child = AddChild<LayerImpl>(parent);
   LayerImpl* grand_child1 = AddChild<LayerImpl>(child);
+  grand_child1->SetDrawsContent(true);
   LayerImpl* grand_child2 = AddChild<LayerImpl>(child);
+  grand_child2->SetDrawsContent(true);
   LayerImpl* grand_child3 = AddChild<LayerImpl>(child);
+  grand_child3->SetDrawsContent(true);
   LayerImpl* grand_child4 = AddChild<LayerImpl>(child);
+  grand_child4->SetDrawsContent(true);
 
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(500, 500), true, false,
                                true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(20, 20), true, false,
                                true);
   SetLayerPropertiesForTesting(grand_child1, identity_matrix, gfx::Point3F(),
                                gfx::PointF(5.f, 5.f), gfx::Size(10, 10), true,
                                false, false);
@@ skipping 291 matching lines @@
   LayerImpl* parent = root_layer();
   LayerImpl* render_surface1 = AddChildToRoot<LayerImpl>();
   LayerImpl* child_of_rs1 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* grand_child_of_rs1 = AddChild<LayerImpl>(child_of_rs1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(render_surface1);
   LayerImpl* child_of_rs2 = AddChild<LayerImpl>(render_surface2);
   LayerImpl* grand_child_of_rs2 = AddChild<LayerImpl>(child_of_rs2);
   LayerImpl* child_of_root = AddChildToRoot<LayerImpl>();
   LayerImpl* grand_child_of_root = AddChild<LayerImpl>(child_of_root);
 
+  parent->SetDrawsContent(true);
+  render_surface1->SetDrawsContent(true);
+  child_of_rs1->SetDrawsContent(true);
   grand_child_of_rs1->SetDrawsContent(true);
+  render_surface2->SetDrawsContent(true);
+  child_of_rs2->SetDrawsContent(true);
   grand_child_of_rs2->SetDrawsContent(true);
+  child_of_root->SetDrawsContent(true);
+  grand_child_of_root->SetDrawsContent(true);
 
   gfx::Transform layer_transform;
   layer_transform.Translate(1.0, 1.0);
 
   SetLayerPropertiesForTesting(
       parent, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, true);
   SetLayerPropertiesForTesting(
       render_surface1, layer_transform, gfx::Point3F(0.25f, 0.f, 0.f),
       gfx::PointF(2.5f, 0.f), gfx::Size(10, 10), true, false, true);
@@ skipping 500 matching lines @@
                                gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(child3_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible_layer_rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
 
   // layer visible_layer_rects are clipped by their target surface.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1_layer->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2_layer->visible_layer_rect());
   EXPECT_TRUE(child3_layer->visible_layer_rect().IsEmpty());
 
   // layer drawable_content_rects are not clipped.
@@ skipping 28 matching lines @@
                                false, false);
   SetLayerPropertiesForTesting(grand_child3, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   child->SetMasksToBounds(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child->visible_layer_rect());
 
   // All grandchild visible content rects should be clipped by child.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_layer_rect());
   EXPECT_TRUE(grand_child3->visible_layer_rect().IsEmpty());
 
@@ skipping 62 matching lines @@
   SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // An unclipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree.
   EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f),
             render_surface->render_surface()->DrawableContentRect());
 
@@ skipping 506 matching lines @@
                                true, false, false);
 
   root->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // A clipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree, but also gets clamped by the ancestor's clip.
   EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f),
             render_surface->render_surface()->DrawableContentRect());
 
@@ skipping 44 matching lines @@
 
   root->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_TRUE(render_surface2->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
-  // Layers that do not draw content should have empty visible content rects.

[ajuma, 2015/11/09 23:17:19]

Nit (here and once more below): no need to remove the punctuation on this line.

[jaydasika, 2015/11/09 23:27:58]

Done.

+  // Layers that do not draw content should have empty visible content rects
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface2->visible_layer_rect());
 
   // A clipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree, but also gets clamped by the ancestor's clip.
   EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f),
             render_surface1->render_surface()->DrawableContentRect());
 
   // render_surface1 lives in the "unclipped universe" of render_surface1, and
@@ skipping 270 matching lines @@
   SetLayerPropertiesForTesting(
       child1, child_rotation, gfx::Point3F(25, 25, 0.f),
       gfx::PointF(25.f, 25.f), gfx::Size(50, 50), true, false, false);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
   EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
 
-  // Layers that do not draw content should have empty visible content rects.
+  // Layers that do not draw content should have empty visible content rects
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // The unclipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
   gfx::Rect expected_surface_drawable_content =
       gfx::Rect(50 - diagonal_radius,
                 50 - diagonal_radius,
                 diagonal_radius * 2,
@@ skipping 102 matching lines @@
 
   ExecuteCalculateDrawProperties(root, device_scale_factor);
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_TRUE(render_surface2->render_surface());
 
   // drawable_content_rects for all layers and surfaces are scaled by
   // device_scale_factor.
   EXPECT_EQ(gfx::RectF(200.f, 200.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(0, 0, 200, 200), root->drawable_content_rect());
   EXPECT_EQ(gfx::RectF(10.f, 10.f, 190.f, 190.f),
             render_surface1->render_surface()->DrawableContentRect());
 
   // render_surface2 lives in the "unclipped universe" of render_surface1, and
   // is only implicitly clipped by render_surface1.
   EXPECT_EQ(gfx::RectF(10.f, 10.f, 350.f, 350.f),
             render_surface2->render_surface()->DrawableContentRect());
 
   EXPECT_EQ(gfx::Rect(10, 10, 100, 100), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(150, 150, 100, 100), child2->drawable_content_rect());
@@ skipping 526 matching lines @@
   EXPECT_EQ(2u, update_layer_list().size());
   EXPECT_TRUE(UpdateLayerListContains(front_facing_surface->id()));
   EXPECT_TRUE(UpdateLayerListContains(child1->id()));
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, LayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers not in a surface.
   gfx::Transform identity_matrix;
 
   LayerImpl* parent = root_layer();
+  parent->SetDrawsContent(true);
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                true);
 
   LayerImpl* child = AddChildToRoot<LayerImpl>();
+  child->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child, identity_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, false);
 
-  LayerImpl* child_empty = AddChildToRoot<LayerImpl>();
-  SetLayerPropertiesForTesting(child_empty, identity_matrix, gfx::Point3F(),
-                               gfx::PointF(2.f, 2.f), gfx::Size(), false, true,
-                               false);
+  LayerImpl* child2 = AddChildToRoot<LayerImpl>();
+  child2->SetDrawsContent(true);
+  SetLayerPropertiesForTesting(child2, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(2.f, 2.f), gfx::Size(5, 5), false,
+                               true, false);
 
   float device_scale_factor = 2.5f;
   gfx::Size viewport_size(100, 100);
   ExecuteCalculateDrawProperties(parent, device_scale_factor);
 
   EXPECT_IDEAL_SCALE_EQ(device_scale_factor, parent);
   EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child);
-  EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child_empty);
+  EXPECT_IDEAL_SCALE_EQ(device_scale_factor, child2);
 
   EXPECT_EQ(1u, render_surface_layer_list_impl()->size());
 
   // Verify parent transforms
   gfx::Transform expected_parent_transform;
   expected_parent_transform.Scale(device_scale_factor, device_scale_factor);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->draw_transform());
 
   // Verify results of transformed parent rects
   gfx::RectF parent_bounds(gfx::SizeF(parent->bounds()));
 
   gfx::RectF parent_draw_rect =
       MathUtil::MapClippedRect(parent->draw_transform(), parent_bounds);
   gfx::RectF parent_screen_space_rect =
       MathUtil::MapClippedRect(parent->screen_space_transform(), parent_bounds);
 
   gfx::RectF expected_parent_draw_rect(gfx::SizeF(parent->bounds()));
   expected_parent_draw_rect.Scale(device_scale_factor);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
 
-  // Verify child and child_empty transforms. They should match.
+  // Verify child and child2 transforms. They should match.
   gfx::Transform expected_child_transform;
   expected_child_transform.Scale(device_scale_factor, device_scale_factor);
   expected_child_transform.Translate(child->position().x(),
                                      child->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_empty->draw_transform());
+                                  child2->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
-                                  child_empty->screen_space_transform());
+                                  child2->screen_space_transform());
 
-  // Verify results of transformed child and child_empty rects. They should
+  // Verify results of transformed child and child2 rects. They should
   // match.
   gfx::RectF child_bounds(gfx::SizeF(child->bounds()));
 
   gfx::RectF child_draw_rect =
       MathUtil::MapClippedRect(child->draw_transform(), child_bounds);
   gfx::RectF child_screen_space_rect =
       MathUtil::MapClippedRect(child->screen_space_transform(), child_bounds);
 
-  gfx::RectF child_empty_draw_rect =
-      MathUtil::MapClippedRect(child_empty->draw_transform(), child_bounds);
-  gfx::RectF child_empty_screen_space_rect = MathUtil::MapClippedRect(
-      child_empty->screen_space_transform(), child_bounds);
+  gfx::RectF child2_draw_rect =
+      MathUtil::MapClippedRect(child2->draw_transform(), child_bounds);
+  gfx::RectF child2_screen_space_rect =
+      MathUtil::MapClippedRect(child2->screen_space_transform(), child_bounds);
 
   gfx::RectF expected_child_draw_rect(child->position(),
                                       gfx::SizeF(child->bounds()));
   expected_child_draw_rect.Scale(device_scale_factor);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect);
-  EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_empty_draw_rect);
-  EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_empty_screen_space_rect);
+  EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_draw_rect);
+  EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child2_screen_space_rect);
 }
 
 TEST_F(LayerTreeHostCommonScalingTest, SurfaceLayerTransformsInHighDPI) {
   // Verify draw and screen space transforms of layers in a surface.
   gfx::Transform identity_matrix;
   gfx::Transform perspective_matrix;
   perspective_matrix.ApplyPerspectiveDepth(2.0);
 
   gfx::Transform scale_small_matrix;
   scale_small_matrix.Scale(SK_MScalar1 / 10.f, SK_MScalar1 / 12.f);
 
   LayerImpl* root = root_layer();
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  parent->SetDrawsContent(true);
   SetLayerPropertiesForTesting(parent, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   LayerImpl* perspective_surface = AddChild<LayerImpl>(parent);
   SetLayerPropertiesForTesting(perspective_surface,
                                perspective_matrix * scale_small_matrix,
                                gfx::Point3F(), gfx::PointF(2.f, 2.f),
                                gfx::Size(10, 10), false, true, true);
   perspective_surface->SetDrawsContent(true);
@@ skipping 70 matching lines @@
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 0.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   LayerImpl* root = root_layer();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  parent->SetDrawsContent(true);
   SetLayerPropertiesForTesting(parent, parent_scale_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   LayerImpl* child_scale = AddChild<LayerImpl>(parent);
+  child_scale->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child_scale, child_scale_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, false);
 
   float device_scale_factor = 2.5f;
   float page_scale_factor = 0.01f;
 
   {
     ExecuteCalculateDrawProperties(root, device_scale_factor, page_scale_factor,
                                    root);
@@ skipping 17 matching lines @@
   parent_scale_matrix.Scale(initial_parent_scale, initial_parent_scale);
 
   gfx::Transform child_scale_matrix;
   SkMScalar initial_child_scale = 1.25;
   child_scale_matrix.Scale(initial_child_scale, initial_child_scale);
 
   LayerImpl* root = root_layer();
   root->SetBounds(gfx::Size(100, 100));
 
   LayerImpl* parent = AddChildToRoot<LayerImpl>();
+  parent->SetDrawsContent(true);
   SetLayerPropertiesForTesting(parent, parent_scale_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), false, true,
                                false);
 
   LayerImpl* child_scale = AddChild<LayerImpl>(parent);
+  child_scale->SetDrawsContent(true);
   SetLayerPropertiesForTesting(child_scale, child_scale_matrix, gfx::Point3F(),
                                gfx::PointF(2.f, 2.f), gfx::Size(10, 10), false,
                                true, false);
 
   {
     ExecuteCalculateDrawProperties(root);
 
     EXPECT_IDEAL_SCALE_EQ(initial_parent_scale, parent);
     // Animating layers compute ideal scale in the same way as when
     // they are static.
@@ skipping 935 matching lines @@
   //        + intervening (masks to bounds)
   //          + render_surface2 (also sets opacity)
   //            + clip_child
   //
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* intervening = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(intervening);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
+  render_surface1->SetDrawsContent(true);
+  render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
   clip_child->SetClipParent(clip_parent);
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
   gfx::Transform translation_transform;
   translation_transform.Translate(2, 2);
 
@@ skipping 71 matching lines @@
   //        + intervening (masks to bounds AND scrolls)
   //          + render_surface2 (also sets opacity)
   //            + clip_child
   //
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* render_surface1 = AddChild<LayerImpl>(clip_parent);
   LayerImpl* intervening = AddChild<LayerImpl>(render_surface1);
   LayerImpl* render_surface2 = AddChild<LayerImpl>(intervening);
   LayerImpl* clip_child = AddChild<LayerImpl>(render_surface2);
+  render_surface1->SetDrawsContent(true);
+  render_surface2->SetDrawsContent(true);
   clip_child->SetDrawsContent(true);
 
   clip_child->SetClipParent(clip_parent);
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
   intervening->SetScrollClipLayer(clip_parent->id());
   intervening->SetCurrentScrollOffset(gfx::ScrollOffset(3, 3));
 
   gfx::Transform translation_transform;
@@ skipping 69 matching lines @@
   //    + clip_parent (masks to bounds)
   //      + intervening (masks to bounds)
   //        + clip_child
   //          + child
   //
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChild<LayerImpl>(root);
   LayerImpl* intervening = AddChild<LayerImpl>(clip_parent);
   LayerImpl* clip_child = AddChild<LayerImpl>(intervening);
   LayerImpl* child = AddChild<LayerImpl>(clip_child);
+  clip_child->SetDrawsContent(true);
   child->SetDrawsContent(true);
 
   clip_child->SetClipParent(clip_parent);
   scoped_ptr<std::set<LayerImpl*>> clip_children(new std::set<LayerImpl*>);
   clip_children->insert(clip_child);
   clip_parent->SetClipChildren(clip_children.release());
 
   intervening->SetMasksToBounds(true);
   clip_parent->SetMasksToBounds(true);
 
@@ skipping 832 matching lines @@
   scoped_ptr<LayerImpl> scroller =
       LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* scroll_layer = scroller.get();
   scoped_ptr<LayerImpl> fixed = LayerImpl::Create(host_impl.active_tree(), 4);
   LayerImpl* fixed_layer = fixed.get();
 
   container->SetIsContainerForFixedPositionLayers(true);
 
   LayerPositionConstraint constraint;
   constraint.set_is_fixed_position(true);
+  container->SetDrawsContent(true);
+  fixed->SetDrawsContent(true);
   fixed->SetPositionConstraint(constraint);
 
+  scroller->SetDrawsContent(true);
   scroller->SetScrollClipLayer(container->id());
 
   gfx::Transform identity_transform;
   gfx::Transform container_transform;
   container_transform.Translate3d(10.0, 20.0, 0.0);
   gfx::Vector2dF container_offset = container_transform.To2dTranslation();
 
   SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
@@ skipping 2384 matching lines @@
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
   SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   root->SetMasksToBounds(true);
+  root->SetDrawsContent(true);
   render_surface->SetMasksToBounds(true);
+  render_surface->SetDrawsContent(true);
   test_layer->SetMasksToBounds(true);
   test_layer->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root);
 
   EXPECT_EQ(gfx::Rect(30, 30), root->clip_rect());
   EXPECT_EQ(gfx::Rect(50, 50), render_surface->clip_rect());
   EXPECT_EQ(gfx::Rect(50, 50), test_layer->clip_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, TwoUnclippedRenderSurfaces) {
@@ skipping 49 matching lines @@
                                true);
   SetLayerPropertiesForTesting(render_surface1, large_transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(render_surface2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_TRUE(std::isinf(
-      render_surface2->render_surface()->draw_transform().matrix().get(0, 0)));
-  EXPECT_TRUE(std::isinf(
-      render_surface2->render_surface()->draw_transform().matrix().get(1, 1)));
+  bool is_inf_or_nan =
+      std::isinf(
+          render_surface2->render_surface()->draw_transform().matrix().get(
+              0, 0)) ||
+      std::isnan(
+          render_surface2->render_surface()->draw_transform().matrix().get(0,
+                                                                           0));
+  EXPECT_TRUE(is_inf_or_nan);
+  is_inf_or_nan =
+      std::isinf(
+          render_surface2->render_surface()->draw_transform().matrix().get(
+              1, 1)) ||
+      std::isnan(
+          render_surface2->render_surface()->draw_transform().matrix().get(1,
+                                                                           1));
+  EXPECT_TRUE(is_inf_or_nan);
   EXPECT_EQ(gfx::RectF(),
             render_surface2->render_surface()->DrawableContentRect());
 
   std::vector<LayerImpl*>* rsll = render_surface_layer_list_impl();
   bool root_in_rsll =
       std::find(rsll->begin(), rsll->end(), root) != rsll->end();
   EXPECT_TRUE(root_in_rsll);
   bool render_surface2_in_rsll =
       std::find(rsll->begin(), rsll->end(), render_surface2) != rsll->end();
   EXPECT_FALSE(render_surface2_in_rsll);
 }
 
 }  // namespace
 }  // namespace cc