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

cc/layers/layer_position_constraint_unittest.cc

 // Copyright 2013 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/layers/layer_position_constraint.h"
 
 #include <vector>
 
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 206 matching lines @@
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform = expected_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->draw_transform());
 
   // Case 2: scroll delta of 10, 10
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   expected_child_transform.MakeIdentity();
   expected_child_transform.Translate(-10.0, -10.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
@@ skipping 33 matching lines @@
   // This test checks for correct scroll compensation when the fixed-position
   // container is NOT the direct parent of the fixed-position layer.
   child_->SetIsContainerForFixedPositionLayers(true);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   expected_grand_child_transform.Translate(8.0, 6.0);
 
   gfx::Transform expected_great_grand_child_transform =
       expected_grand_child_transform;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
@@ skipping 64 matching lines @@
 
   child_transform_layer_->SetIsContainerForFixedPositionLayers(true);
   child_transform_layer_->SetTransform(rotation_about_z);
   grand_child_->SetPosition(gfx::PointF(8.f, 6.f));
   great_grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   expected_child_transform.PreconcatTransform(rotation_about_z);
 
   gfx::Transform expected_grand_child_transform;
   expected_grand_child_transform.PreconcatTransform(
       rotation_about_z);  // child's local transform is inherited
   // translation because of position occurs before layer's local transform.
   expected_grand_child_transform.Translate(8.0, 6.0);
@@ skipping 70 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_surface_draw_transform,
       grand_child_impl_->render_surface()->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_great_grand_child_transform,
                                   great_grand_child_impl_->draw_transform());
 
   // Case 2: scroll delta of 10, 30
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 30));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the grand_child remains unchanged, because it scrolls along with the
   // render surface, and the translation is actually in the render surface. But,
   // the fixed position great_grand_child is more awkward: its actually being
   // drawn with respect to the render surface, but it needs to remain fixed with
   // resepct to a container beyond that surface. So, the net result is that,
   // unlike previous tests where the fixed position layer's transform remains
   // unchanged, here the fixed position layer's transform explicitly contains
   // the translation that cancels out the scroll.
@@ skipping 91 matching lines @@
   rotation_about_z.Translate(50.0, 50.0);
   rotation_about_z.RotateAboutZAxis(90.0);
   rotation_about_z.Translate(-50.0, -50.0);
   fixed_position_child->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
   LayerImpl* fixed_position_child_impl = great_grand_child_impl_->children()[0];
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
 
   gfx::Transform expected_grand_child_surface_draw_transform;
   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
 
   gfx::Transform expected_grand_child_transform;
 
   gfx::Transform expected_great_grand_child_surface_draw_transform;
@@ skipping 136 matching lines @@
   rotation_about_z.RotateAboutZAxis(90.0);
   rotation_about_z.Translate(-50.0, -50.0);
   child_transform_layer_->SetTransform(rotation_about_z);
   fixed_position_child->SetTransform(rotation_about_z);
 
   CommitAndUpdateImplPointers();
   LayerImpl* fixed_position_child_impl = great_grand_child_impl_->children()[0];
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   expected_child_transform.PreconcatTransform(rotation_about_z);
 
   gfx::Transform expected_grand_child_surface_draw_transform;
   expected_grand_child_surface_draw_transform.PreconcatTransform(
       rotation_about_z);
   expected_grand_child_surface_draw_transform.Translate(8.0, 6.0);
 
@@ skipping 161 matching lines @@
   grand_child_->SetPositionConstraint(fixed_to_top_left_);
 
   // This should not confuse the grand_child. If correct, the grand_child would
   // still be considered fixed to its container (i.e. "child").
   grand_child_->SetIsContainerForFixedPositionLayers(true);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scroll delta of 0, 0
   child_impl_->SetScrollDelta(gfx::Vector2d(0, 0));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_child_transform;
   gfx::Transform expected_grand_child_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_impl_->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_grand_child_transform,
                                   grand_child_impl_->draw_transform());
 
   // Case 2: scroll delta of 10, 10
@@ skipping 50 matching lines @@
 
   // Note carefully - great_grand_child is fixed to bottom right, to test
   // sizeDelta being applied correctly; the compensation skips the grand_child
   // because it is fixed to top left.
   great_grand_child_->SetPositionConstraint(fixed_to_bottom_right_);
 
   CommitAndUpdateImplPointers();
 
   // Case 1: scrollDelta
   child_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  child_impl_->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Here the child is affected by scroll delta, but the fixed position
   // grand_child should not be affected.
   gfx::Transform expected_child_transform;
   expected_child_transform.Translate(-10.0, -10.0);
 
   gfx::Transform expected_grand_child_transform;
   gfx::Transform expected_great_grand_child_transform;
 
@@ skipping 44 matching lines @@
   great_great_grand_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   LayerImpl* container1 = child_impl_;
   LayerImpl* fixed_to_container1 = grand_child_impl_;
   LayerImpl* container2 = great_grand_child_impl_;
   LayerImpl* fixed_to_container2 = container2->children()[0];
 
   container1->SetScrollDelta(gfx::Vector2d(0, 15));
+  container1->SetDrawsContent(true);
   container2->SetScrollDelta(gfx::Vector2d(30, 0));
+  container2->SetDrawsContent(true);
   ExecuteCalculateDrawProperties(root_impl_);
 
   gfx::Transform expected_container1_transform;
   expected_container1_transform.Translate(0.0, -15.0);
 
   gfx::Transform expected_fixed_to_container1_transform;
 
   // Since the container is a descendant of the fixed layer above,
   // the expected draw transform for container2 would not
   // include the scrollDelta that was applied to container1.
@@ skipping 25 matching lines @@
   scroll_layer_->AddChild(fixed_child);
   fixed_child->SetPositionConstraint(fixed_to_top_left_);
 
   CommitAndUpdateImplPointers();
 
   LayerImpl* fixed_child_impl =
       root_impl_->layer_tree_impl()->FindActiveTreeLayerById(fixed_child->id());
 
   // Case 1: fixed-container size delta of 20, 20
   scroll_layer_impl_->SetScrollDelta(gfx::Vector2d(10, 10));
+  scroll_layer_impl_->SetDrawsContent(true);
   SetFixedContainerSizeDelta(scroll_layer_impl_, gfx::Vector2d(20, 20));
   gfx::Transform expected_scroll_layer_transform;
   expected_scroll_layer_transform.Translate(-10.0, -10.0);
   gfx::Transform expected_fixed_child_transform;
 
   ExecuteCalculateDrawProperties(root_impl_);
 
   // Top-left fixed-position layer should not be affected by container size.
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_layer_transform,
                                   scroll_layer_impl_->draw_transform());
@@ skipping 16 matching lines @@
   expected_fixed_child_transform.Translate(20.0, 20.0);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_scroll_layer_transform,
                                   scroll_layer_impl_->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_fixed_child_transform,
                                   fixed_child_impl->draw_transform());
 }
 
 }  // namespace
 }  // namespace cc