Update from https://crrev.com/309717

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/layer_animation_controller.h"
@@ skipping 305 matching lines @@
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
 
   gfx::Transform identity_matrix;
   scoped_ptr<LayerImpl> sublayer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 1));
   LayerImpl* sublayer = sublayer_scoped_ptr.get();
   sublayer->SetContentsScale(kPageScale * kDeviceScale,
                              kPageScale * kDeviceScale);
-  SetLayerPropertiesForTesting(sublayer,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(500, 500),
-                               true,
+  SetLayerPropertiesForTesting(sublayer, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(500, 500), true, false,
                                false);
 
   scoped_ptr<LayerImpl> scroll_layer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 2));
   LayerImpl* scroll_layer = scroll_layer_scoped_ptr.get();
-  SetLayerPropertiesForTesting(scroll_layer,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(10, 20),
-                               true,
+  SetLayerPropertiesForTesting(scroll_layer, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(10, 20), true, false,
                                false);
   scoped_ptr<LayerImpl> clip_layer_scoped_ptr(
       LayerImpl::Create(host_impl.active_tree(), 4));
   LayerImpl* clip_layer = clip_layer_scoped_ptr.get();
 
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   clip_layer->SetBounds(
       gfx::Size(scroll_layer->bounds().width() + kMaxScrollOffset.x(),
                 scroll_layer->bounds().height() + kMaxScrollOffset.y()));
   scroll_layer->SetScrollClipLayer(clip_layer->id());
   scroll_layer->SetScrollDelta(kScrollDelta);
   gfx::Transform impl_transform;
   scroll_layer->AddChild(sublayer_scoped_ptr.Pass());
   LayerImpl* scroll_layer_raw_ptr = scroll_layer_scoped_ptr.get();
   clip_layer->AddChild(scroll_layer_scoped_ptr.Pass());
   scroll_layer_raw_ptr->SetScrollOffset(kScrollOffset);
 
   scoped_ptr<LayerImpl> root(LayerImpl::Create(host_impl.active_tree(), 3));
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(3, 4),
-                               true,
+  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(3, 4), true, false,
                                false);
   root->AddChild(clip_layer_scoped_ptr.Pass());
+  root->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
   gfx::Transform expected_transform = identity_matrix;
   gfx::PointF sub_layer_screen_position = kScrollLayerPosition - kScrollDelta;
   sub_layer_screen_position.Scale(kPageScale * kDeviceScale);
   expected_transform.Translate(MathUtil::Round(sub_layer_screen_position.x()),
                                MathUtil::Round(sub_layer_screen_position.y()));
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->screen_space_transform());
 
   gfx::Transform arbitrary_translate;
   const float kTranslateX = 10.6f;
   const float kTranslateY = 20.6f;
   arbitrary_translate.Translate(kTranslateX, kTranslateY);
-  SetLayerPropertiesForTesting(scroll_layer,
-                               arbitrary_translate,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(10, 20),
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(scroll_layer, arbitrary_translate,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(10, 20),
+                               true, false, false);
   ExecuteCalculateDrawProperties(
       root.get(), kDeviceScale, kPageScale, scroll_layer->parent());
   expected_transform.MakeIdentity();
   expected_transform.Translate(
       MathUtil::Round(kTranslateX * kPageScale * kDeviceScale +
                       sub_layer_screen_position.x()),
       MathUtil::Round(kTranslateY * kPageScale * kDeviceScale +
                       sub_layer_screen_position.y()));
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_transform,
                                   sublayer->draw_transform());
@@ skipping 3384 matching lines @@
                                gfx::Size(100, 100),
                                true,
                                true);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  // Verify which render surfaces were created.
+  // Verify which render surfaces were created and used.
   EXPECT_FALSE(front_facing_child->render_surface());
   EXPECT_FALSE(back_facing_child->render_surface());
   EXPECT_TRUE(front_facing_surface->render_surface());
-  EXPECT_FALSE(back_facing_surface->render_surface());
+  EXPECT_NE(back_facing_surface->render_target(), back_facing_surface);
+  // We expect that a render_surface was created but not used.
+  EXPECT_TRUE(back_facing_surface->render_surface());
   EXPECT_FALSE(front_facing_child_of_front_facing_surface->render_surface());
   EXPECT_FALSE(back_facing_child_of_front_facing_surface->render_surface());
   EXPECT_FALSE(front_facing_child_of_back_facing_surface->render_surface());
   EXPECT_FALSE(back_facing_child_of_back_facing_surface->render_surface());
 
   // Verify the render_surface_layer_list. The back-facing surface should be
   // culled.
   ASSERT_EQ(2u, render_surface_layer_list.size());
   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
   EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
@@ skipping 243 matching lines @@
 
   front_facing_surface->Set3dSortingContextId(1);
   back_facing_surface->Set3dSortingContextId(1);
 
   RenderSurfaceLayerList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsMainInputsForTesting inputs(
       parent.get(), parent->bounds(), &render_surface_layer_list);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
-  // Verify which render surfaces were created.
+  // Verify which render surfaces were created and used.
   EXPECT_TRUE(front_facing_surface->render_surface());
-  EXPECT_FALSE(
-      back_facing_surface->render_surface());  // because it should be culled
+
+  // We expect the render surface to have been created, but remain unused.
+  EXPECT_TRUE(back_facing_surface->render_surface());
+  EXPECT_NE(back_facing_surface->render_target(),
+            back_facing_surface);  // because it should be culled
   EXPECT_FALSE(child1->render_surface());
   EXPECT_FALSE(child2->render_surface());
 
   // Verify the render_surface_layer_list. The back-facing surface should be
   // culled.
   ASSERT_EQ(2u, render_surface_layer_list.size());
   EXPECT_EQ(parent->id(), render_surface_layer_list.at(0)->id());
   EXPECT_EQ(front_facing_surface->id(), render_surface_layer_list.at(1)->id());
 
   // Verify root surface's layer list.
@@ skipping 1560 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, OpacityAnimatingOnPendingTree) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
 
   const gfx::Transform identity_matrix;
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(100, 100),
-                               true,
+  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(100, 100), true, false,
                                false);
   root->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2);
-  SetLayerPropertiesForTesting(child.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               true,
+  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   child->SetDrawsContent(true);
   child->SetOpacity(0.0f);
 
   // Add opacity animation.
   AddOpacityTransitionToController(
       child->layer_animation_controller(), 10.0, 0.0f, 1.0f, false);
 
   root->AddChild(child.Pass());
+  root->SetHasRenderSurface(true);
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), 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());
 }
 
 using LCDTextTestParam = std::tr1::tuple<bool, bool, bool>;
 class LCDTextTest
     : public LayerTreeHostCommonTestBase,
       public testing::TestWithParam<LCDTextTestParam> {
  protected:
-  virtual void SetUp() {
+  void SetUp() override {
     can_use_lcd_text_ = std::tr1::get<0>(GetParam());
     layers_always_allowed_lcd_text_ = std::tr1::get<1>(GetParam());
 
     root_ = Layer::Create();
     child_ = Layer::Create();
     grand_child_ = Layer::Create();
     child_->AddChild(grand_child_.get());
     root_->AddChild(child_.get());
 
     root_->SetContentsOpaque(true);
@@ skipping 223 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_SingleLayerImpl) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               true,
+  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   root->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2);
-  SetLayerPropertiesForTesting(child.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(40, 40),
-                               true,
+  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(40, 40), true, false,
                                false);
   child->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
-  SetLayerPropertiesForTesting(grand_child.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(30, 30),
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
+                               true, false, false);
   grand_child->SetDrawsContent(true);
   grand_child->SetHideLayerAndSubtree(true);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.Pass());
+  root->SetHasRenderSurface(true);
 
   LayerImplList render_surface_layer_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root.get(), 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());
@@ skipping 60 matching lines @@
 }
 
 TEST_F(LayerTreeHostCommonTest, SubtreeHidden_TwoLayersImpl) {
   FakeImplProxy proxy;
   TestSharedBitmapManager shared_bitmap_manager;
   FakeLayerTreeHostImpl host_impl(&proxy, &shared_bitmap_manager);
   host_impl.CreatePendingTree();
   const gfx::Transform identity_matrix;
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.pending_tree(), 1);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(root.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(50, 50), true, false,
+                               true);
   root->SetDrawsContent(true);
 
   scoped_ptr<LayerImpl> child = LayerImpl::Create(host_impl.pending_tree(), 2);
-  SetLayerPropertiesForTesting(child.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(40, 40),
-                               true,
+  SetLayerPropertiesForTesting(child.get(), identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(40, 40), true, false,
                                false);
   child->SetDrawsContent(true);
   child->SetHideLayerAndSubtree(true);
 
   scoped_ptr<LayerImpl> grand_child =
       LayerImpl::Create(host_impl.pending_tree(), 3);
-  SetLayerPropertiesForTesting(grand_child.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(30, 30),
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(grand_child.get(), identity_matrix,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
+                               true, false, 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);
   inputs.can_adjust_raster_scales = true;
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
@@ skipping 850 matching lines @@
       LayerImpl::Create(host_impl.active_tree(), 123456);
   scoped_ptr<LayerImpl> child2 =
       LayerImpl::Create(host_impl.active_tree(), 1234567);
   scoped_ptr<LayerImpl> child3 =
       LayerImpl::Create(host_impl.active_tree(), 12345678);
 
   gfx::Transform identity_matrix;
   gfx::Point3F transform_origin;
   gfx::PointF position;
   gfx::Size bounds(100, 100);
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_matrix,
-                               transform_origin,
-                               position,
-                               bounds,
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(root.get(), identity_matrix, transform_origin,
+                               position, bounds, true, false, true);
   root->SetDrawsContent(true);
 
   // This layer structure normally forces render surface due to preserves3d
   // behavior.
-  SetLayerPropertiesForTesting(child1.get(),
-                               identity_matrix,
-                               transform_origin,
-                               position,
-                               bounds,
-                               false,
-                               true);
+  SetLayerPropertiesForTesting(child1.get(), identity_matrix, transform_origin,
+                               position, bounds, false, true, true);
   child1->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child2.get(),
-                               identity_matrix,
-                               transform_origin,
-                               position,
-                               bounds,
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(child2.get(), identity_matrix, transform_origin,
+                               position, bounds, true, false, false);
   child2->SetDrawsContent(true);
-  SetLayerPropertiesForTesting(child3.get(),
-                               identity_matrix,
-                               transform_origin,
-                               position,
-                               bounds,
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(child3.get(), identity_matrix, transform_origin,
+                               position, bounds, true, false, false);
   child3->SetDrawsContent(true);
 
   child2->Set3dSortingContextId(1);
   child3->Set3dSortingContextId(1);
 
   child2->AddChild(child3.Pass());
   child1->AddChild(child2.Pass());
   root->AddChild(child1.Pass());
 
   {
@@ skipping 621 matching lines @@
   scroll_parent->SetDrawsContent(true);
   top_content->SetDrawsContent(true);
   bottom_content->SetDrawsContent(true);
 
   gfx::Transform identity_transform;
   gfx::Transform top_transform;
   top_transform.Translate3d(0.0, 0.0, 5.0);
   gfx::Transform bottom_transform;
   bottom_transform.Translate3d(0.0, 0.0, 3.0);
 
-  SetLayerPropertiesForTesting(root.get(),
-                               identity_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(scroll_parent_border.get(),
-                               identity_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(40, 40),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(scroll_parent_clip.get(),
-                               identity_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(30, 30),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(scroll_parent.get(),
-                               identity_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(scroll_child.get(),
-                               identity_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(top_content.get(),
-                               top_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               false,
+  SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(50, 50), true, false,
                                true);
-  SetLayerPropertiesForTesting(bottom_content.get(),
-                               bottom_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               false,
+  SetLayerPropertiesForTesting(scroll_parent_border.get(), identity_transform,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
+                               true, false, false);
+  SetLayerPropertiesForTesting(scroll_parent_clip.get(), identity_transform,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
+                               true, false, false);
+  SetLayerPropertiesForTesting(scroll_parent.get(), identity_transform,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
+                               true, false, false);
+  SetLayerPropertiesForTesting(scroll_child.get(), identity_transform,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
+                               true, false, false);
+  SetLayerPropertiesForTesting(top_content.get(), top_transform, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(50, 50), false, true,
                                true);
+  SetLayerPropertiesForTesting(bottom_content.get(), bottom_transform,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(50, 50),
+                               false, true, true);
 
   scroll_child->SetShouldFlattenTransform(false);
   scroll_child->Set3dSortingContextId(1);
 
   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());
@@ skipping 49 matching lines @@
   constraint.set_is_fixed_position(true);
   fixed->SetPositionConstraint(constraint);
 
   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);
-  SetLayerPropertiesForTesting(container.get(),
-                               container_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(40, 40),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(scroller.get(),
-                               identity_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(30, 30),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(fixed.get(),
-                               identity_transform,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(50, 50),
-                               true,
+  SetLayerPropertiesForTesting(root.get(), identity_transform, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(50, 50), true, false,
+                               true);
+  SetLayerPropertiesForTesting(container.get(), container_transform,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(40, 40),
+                               true, false, false);
+  SetLayerPropertiesForTesting(scroller.get(), identity_transform,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(30, 30),
+                               true, false, false);
+  SetLayerPropertiesForTesting(fixed.get(), identity_transform, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
 
   scroller->AddChild(fixed.Pass());
   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);
@@ skipping 117 matching lines @@
       AnimationScaleFactorTrackingLayerImpl::Create(host_impl.active_tree(), 4);
 
   AnimationScaleFactorTrackingLayerImpl* parent_raw = parent.get();
   AnimationScaleFactorTrackingLayerImpl* child_raw = child.get();
   AnimationScaleFactorTrackingLayerImpl* grand_child_raw = grand_child.get();
 
   child->AddChild(grand_child.Pass());
   parent->AddChild(child.Pass());
   grand_parent->AddChild(parent.Pass());
 
-  SetLayerPropertiesForTesting(grand_parent.get(),
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
+  SetLayerPropertiesForTesting(grand_parent.get(), identity_matrix,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
+                               true, false, true);
+  SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
-  SetLayerPropertiesForTesting(parent_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
+  SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
-  SetLayerPropertiesForTesting(child_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(grand_child_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
+
+  SetLayerPropertiesForTesting(grand_child_raw, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(grand_parent.get());
 
   // No layers have animations.
   EXPECT_EQ(0.f,
             grand_parent->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().maximum_animation_contents_scale);
   EXPECT_EQ(0.f, child_raw->draw_properties().maximum_animation_contents_scale);
@@ skipping 189 matching lines @@
   LayerImpl* parent_raw = parent.get();
   LayerImpl* child_raw = child.get();
   LayerImpl* grand_child1_raw = grand_child1.get();
   LayerImpl* grand_child2_raw = grand_child2.get();
 
   child->AddChild(grand_child1.Pass());
   child->AddChild(grand_child2.Pass());
   parent->AddChild(child.Pass());
   grand_parent->AddChild(parent.Pass());
 
-  SetLayerPropertiesForTesting(grand_parent_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
+  SetLayerPropertiesForTesting(grand_parent_raw, identity_matrix,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
+                               true, false, true);
+  SetLayerPropertiesForTesting(parent_raw, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
-  SetLayerPropertiesForTesting(parent_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
+
+  SetLayerPropertiesForTesting(child_raw, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(1, 2), true, false,
                                false);
-  SetLayerPropertiesForTesting(child_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(grand_child1_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(grand_child2_raw,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 2),
-                               true,
-                               false);
+
+  SetLayerPropertiesForTesting(grand_child1_raw, identity_matrix,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
+                               true, false, false);
+
+  SetLayerPropertiesForTesting(grand_child2_raw, identity_matrix,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(1, 2),
+                               true, false, false);
 
   // Start with nothing being drawn.
   ExecuteCalculateDrawProperties(grand_parent_raw);
   int member_id = render_surface_layer_list_count();
 
   EXPECT_NE(member_id, membership_id(grand_parent_raw));
   EXPECT_NE(member_id, membership_id(parent_raw));
   EXPECT_NE(member_id, membership_id(child_raw));
   EXPECT_NE(member_id, membership_id(grand_child1_raw));
   EXPECT_NE(member_id, membership_id(grand_child2_raw));
 
   std::set<LayerImpl*> expected;
   std::set<LayerImpl*> actual;
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // If we force render surface, but none of the layers are in the layer list,
   // then this layer should not appear in RSLL.
-  grand_child1_raw->SetForceRenderSurface(true);
+  grand_child1_raw->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
   member_id = render_surface_layer_list_count();
 
   EXPECT_NE(member_id, membership_id(grand_parent_raw));
   EXPECT_NE(member_id, membership_id(parent_raw));
   EXPECT_NE(member_id, membership_id(child_raw));
   EXPECT_NE(member_id, membership_id(grand_child1_raw));
   EXPECT_NE(member_id, membership_id(grand_child2_raw));
 
@@ skipping 18 matching lines @@
   expected.clear();
   expected.insert(grand_child1_raw);
 
   actual.clear();
   GatherDrawnLayers(render_surface_layer_list_impl(), &actual);
   EXPECT_EQ(expected, actual);
 
   // Now child is forced to have a render surface, and one if its children draws
   // content.
   grand_child1_raw->SetDrawsContent(false);
-  grand_child1_raw->SetForceRenderSurface(false);
-  child_raw->SetForceRenderSurface(true);
+  grand_child1_raw->SetHasRenderSurface(false);
+  child_raw->SetHasRenderSurface(true);
   grand_child2_raw->SetDrawsContent(true);
 
   ExecuteCalculateDrawProperties(grand_parent_raw);
   member_id = render_surface_layer_list_count();
 
   EXPECT_NE(member_id, membership_id(grand_parent_raw));
   EXPECT_NE(member_id, membership_id(parent_raw));
   EXPECT_NE(member_id, membership_id(child_raw));
   EXPECT_NE(member_id, membership_id(grand_child1_raw));
   EXPECT_EQ(member_id, membership_id(grand_child2_raw));
@@ skipping 134 matching lines @@
 
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl.active_tree(), 1);
   LayerImpl* root_layer = root.get();
   scoped_ptr<LayerImpl> child1 = LayerImpl::Create(host_impl.active_tree(), 2);
   LayerImpl* child1_layer = child1.get();
   scoped_ptr<LayerImpl> child2 = LayerImpl::Create(host_impl.active_tree(), 3);
   LayerImpl* child2_layer = child2.get();
 
   root->AddChild(child1.Pass());
   root->AddChild(child2.Pass());
+  root->SetHasRenderSurface(true);
 
   gfx::Transform identity_matrix, scale_transform_child1,
       scale_transform_child2;
   scale_transform_child1.Scale(2, 3);
   scale_transform_child2.Scale(4, 5);
 
-  SetLayerPropertiesForTesting(root_layer,
-                               identity_matrix,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(1, 1),
-                               true,
-                               false);
-  SetLayerPropertiesForTesting(child1_layer,
-                               scale_transform_child1,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(),
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(root_layer, identity_matrix, gfx::Point3F(),
+                               gfx::PointF(), gfx::Size(1, 1), true, false,
+                               true);
+  SetLayerPropertiesForTesting(child1_layer, scale_transform_child1,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
+                               false, false);
 
   child1_layer->SetMaskLayer(
       LayerImpl::Create(host_impl.active_tree(), 4).Pass());
 
   scoped_ptr<LayerImpl> replica_layer =
       LayerImpl::Create(host_impl.active_tree(), 5);
+  replica_layer->SetHasRenderSurface(true);
   replica_layer->SetMaskLayer(LayerImpl::Create(host_impl.active_tree(), 6));
   child1_layer->SetReplicaLayer(replica_layer.Pass());
+  child1_layer->SetHasRenderSurface(true);
 
   ExecuteCalculateDrawProperties(root_layer);
 
   TransformOperations scale;
   scale.AppendScale(5.f, 8.f, 3.f);
 
   AddAnimatedTransformToLayer(child2_layer, 1.0, TransformOperations(), scale);
-  SetLayerPropertiesForTesting(child2_layer,
-                               scale_transform_child2,
-                               gfx::Point3F(),
-                               gfx::PointF(),
-                               gfx::Size(),
-                               true,
-                               false);
+  SetLayerPropertiesForTesting(child2_layer, scale_transform_child2,
+                               gfx::Point3F(), gfx::PointF(), gfx::Size(), true,
+                               false, false);
 
   ExecuteCalculateDrawProperties(root_layer);
 
   EXPECT_FLOAT_EQ(1.f, root_layer->draw_properties().ideal_contents_scale);
   EXPECT_FLOAT_EQ(3.f, child1_layer->draw_properties().ideal_contents_scale);
   EXPECT_FLOAT_EQ(
       3.f, child1_layer->mask_layer()->draw_properties().ideal_contents_scale);
   EXPECT_FLOAT_EQ(3.f,
                   child1_layer->replica_layer()
                       ->mask_layer()
@@ skipping 240 matching lines @@
   host_impl.active_tree()->SetRootLayer(
       LayerImpl::Create(host_impl.active_tree(), 1));
 
   LayerImpl* root = host_impl.active_tree()->root_layer();
   SetLayerPropertiesForTesting(root,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                root_size,
                                false,
-                               false);
+                               false,
+                               true);
 
   root->SetContentBounds(root_size);
   root->SetMasksToBounds(true);
 
   root->AddChild(LayerImpl::Create(host_impl.active_tree(), 2));
 
   LayerImpl* sublayer = root->child_at(0);
   SetLayerPropertiesForTesting(sublayer,
                                identity_matrix,
                                gfx::Point3F(),
                                gfx::PointF(),
                                sublayer_size,
                                false,
+                               false,
                                false);
 
   sublayer->SetContentBounds(sublayer_size);
   sublayer->SetDrawsContent(true);
 
   LayerImplList layer_impl_list;
   LayerTreeHostCommon::CalcDrawPropsImplInputsForTesting inputs(
       root, device_viewport_size, &layer_impl_list);
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   EXPECT_EQ(gfx::Rect(root_size), sublayer->visible_content_rect());
 
   root->SetBoundsDelta(gfx::Vector2dF(0.0, 50.0));
 
   LayerTreeHostCommon::CalculateDrawProperties(&inputs);
 
   gfx::Rect affected_by_delta(0, 0, root_size.width(),
                               root_size.height() + 50);
   EXPECT_EQ(affected_by_delta, sublayer->visible_content_rect());
 }
 
 }  // namespace
 }  // namespace cc