Moving RenderSurface creation outside of CalcDrawProps

cc/layers/delegated_renderer_layer_impl_unittest.cc

 // Copyright 2012 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/delegated_renderer_layer_impl.h"
 
 #include "cc/base/scoped_ptr_vector.h"
 #include "cc/layers/solid_color_layer_impl.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/solid_color_draw_quad.h"
@@ skipping 51 matching lines @@
         host_impl_->active_tree(), 1).PassAs<LayerImpl>();
     scoped_ptr<LayerImpl> layer_before = SolidColorLayerImpl::Create(
         host_impl_->active_tree(), 2).PassAs<LayerImpl>();
     scoped_ptr<LayerImpl> layer_after = SolidColorLayerImpl::Create(
         host_impl_->active_tree(), 3).PassAs<LayerImpl>();
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
 
     host_impl_->SetViewportSize(gfx::Size(100, 100));
     root_layer->SetBounds(gfx::Size(100, 100));
+    root_layer->SetHasRenderSurface(true);
 
     layer_before->SetPosition(gfx::Point(20, 20));
     layer_before->SetBounds(gfx::Size(14, 14));
     layer_before->SetContentBounds(gfx::Size(14, 14));
     layer_before->SetDrawsContent(true);
-    layer_before->SetForceRenderSurface(true);
+    layer_before->SetHasRenderSurface(true);
 
     layer_after->SetPosition(gfx::Point(5, 5));
     layer_after->SetBounds(gfx::Size(15, 15));
     layer_after->SetContentBounds(gfx::Size(15, 15));
     layer_after->SetDrawsContent(true);
-    layer_after->SetForceRenderSurface(true);
+    layer_after->SetHasRenderSurface(true);
 
     delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
     delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
     delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
     delegated_renderer_layer->SetDrawsContent(true);
     gfx::Transform transform;
     transform.Translate(1.0, 1.0);
     delegated_renderer_layer->SetTransform(transform);
 
     RenderPassList delegated_render_passes;
@@ skipping 194 matching lines @@
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       transform * five_six, frame.render_passes[1]->transform_to_root_target);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       transform * seven_eight,
       frame.render_passes[2]->transform_to_root_target);
 
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
-TEST_F(DelegatedRendererLayerImplTestSimple, DoesNotOwnARenderSurface) {
-  LayerTreeHostImpl::FrameData frame;
-  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-
-  // If the DelegatedRendererLayer is axis aligned and has opacity 1, then it
-  // has no need to be a RenderSurface for the quads it carries.
-  EXPECT_FALSE(delegated_renderer_layer_->render_surface());
-
-  host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
-  host_impl_->DidDrawAllLayers(frame);
-}
-
-TEST_F(DelegatedRendererLayerImplTestSimple, DoesOwnARenderSurfaceForOpacity) {
-  delegated_renderer_layer_->SetOpacity(0.5f);
-
-  LayerTreeHostImpl::FrameData frame;
-  FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
-      host_impl_->active_tree()->root_layer());
-  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-
-  // This test case has quads from multiple layers in the delegated renderer, so
-  // if the DelegatedRendererLayer has opacity < 1, it should end up with a
-  // render surface.
-  EXPECT_TRUE(delegated_renderer_layer_->render_surface());
-
-  host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
-  host_impl_->DidDrawAllLayers(frame);
-}
-
-TEST_F(DelegatedRendererLayerImplTestSimple,
-       DoesOwnARenderSurfaceForTransform) {
-  gfx::Transform rotation;
-  rotation.RotateAboutZAxis(30.0);
-  delegated_renderer_layer_->SetTransform(rotation);
-
-  LayerTreeHostImpl::FrameData frame;
-  FakeLayerTreeHostImpl::RecursiveUpdateNumChildren(
-      host_impl_->active_tree()->root_layer());
-  EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
-
-  // This test case has quads from multiple layers in the delegated renderer, so
-  // if the DelegatedRendererLayer has opacity < 1, it should end up with a
-  // render surface.
-  EXPECT_TRUE(delegated_renderer_layer_->render_surface());
-
-  host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
-  host_impl_->DidDrawAllLayers(frame);
-}
-
 class DelegatedRendererLayerImplTestOwnSurface
     : public DelegatedRendererLayerImplTestSimple {
  public:
   DelegatedRendererLayerImplTestOwnSurface()
       : DelegatedRendererLayerImplTestSimple() {
-    delegated_renderer_layer_->SetForceRenderSurface(true);
+    delegated_renderer_layer_->SetHasRenderSurface(true);
   }
 };
 
 TEST_F(DelegatedRendererLayerImplTestOwnSurface, AddsRenderPasses) {
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   // Each non-DelegatedRendererLayer added one RenderPass. The
   // DelegatedRendererLayer added two contributing passes and its owned surface
   // added one pass.
@@ skipping 129 matching lines @@
   void SetUpTest() {
     host_impl_->SetDeviceScaleFactor(2.f);
 
     scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
         host_impl_->active_tree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
 
     host_impl_->SetViewportSize(gfx::Size(200, 200));
     root_layer->SetBounds(gfx::Size(100, 100));
+    root_layer->SetHasRenderSurface(true);
 
     delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
     delegated_renderer_layer->SetBounds(gfx::Size(75, 75));
     delegated_renderer_layer->SetContentBounds(gfx::Size(75, 75));
     delegated_renderer_layer->SetDrawsContent(true);
     gfx::Transform transform;
     transform.Scale(2.0, 2.0);
     transform.Translate(8.0, 8.0);
     delegated_renderer_layer->SetTransform(transform);
 
@@ skipping 275 matching lines @@
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   SetUpTest();
 
-  delegated_renderer_layer_->SetForceRenderSurface(true);
+  delegated_renderer_layer_->SetHasRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
@@ skipping 27 matching lines @@
       contrib_delegated_shared_quad_state->content_to_target_transform);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestTransform, QuadsClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   SetUpTest();
 
-  delegated_renderer_layer_->SetForceRenderSurface(true);
+  delegated_renderer_layer_->SetHasRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   const SharedQuadState* root_delegated_shared_quad_state = NULL;
   const SharedQuadState* contrib_delegated_shared_quad_state = NULL;
   VerifyRenderPasses(
       frame,
       3,
       &root_delegated_shared_quad_state,
@@ skipping 76 matching lines @@
         LayerImpl::Create(host_impl_->active_tree(), 1);
     scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
         FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 2);
     scoped_ptr<LayerImpl> clip_layer =
         LayerImpl::Create(host_impl_->active_tree(), 3);
     scoped_ptr<LayerImpl> origin_layer =
         LayerImpl::Create(host_impl_->active_tree(), 4);
 
     host_impl_->SetViewportSize(gfx::Size(100, 100));
     root_layer->SetBounds(gfx::Size(100, 100));
+    root_layer->SetHasRenderSurface(true);
 
     delegated_renderer_layer->SetPosition(gfx::Point(20, 20));
     delegated_renderer_layer->SetBounds(gfx::Size(50, 50));
     delegated_renderer_layer->SetContentBounds(gfx::Size(50, 50));
     delegated_renderer_layer->SetDrawsContent(true);
 
     RenderPassList delegated_render_passes;
 
     gfx::Size child_pass_content_bounds(7, 7);
     gfx::Rect child_pass_rect(20, 20, 7, 7);
@@ skipping 247 matching lines @@
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
-  delegated_renderer_layer_->SetForceRenderSurface(true);
+  delegated_renderer_layer_->SetHasRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
 
   // When the layer owns a surface, the quads don't need to be clipped
   // further than they already specify. If they aren't clipped, then their
   // clip rect is ignored, and they are not set as clipped.
   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsClipped_LayerUnclipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = false;
   SetUpTest();
 
-  delegated_renderer_layer_->SetForceRenderSurface(true);
+  delegated_renderer_layer_->SetHasRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
 
   // When the quads have a clip of their own, it is used.
   EXPECT_EQ(gfx::Rect(5, 5, 40, 40).ToString(),
             root_delegated_shared_quad_state->clip_rect.ToString());
   // Quads came with a clip rect.
   EXPECT_TRUE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip,
        QuadsUnclipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = false;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
-  delegated_renderer_layer_->SetForceRenderSurface(true);
+  delegated_renderer_layer_->SetHasRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
   const SharedQuadState* root_delegated_shared_quad_state =
       root_delegated_quad_list[0]->shared_quad_state;
 
   // When the layer owns a surface, the quads don't need to be clipped
   // further than they already specify. If they aren't clipped, then their
   // clip rect is ignored, and they are not set as clipped.
   EXPECT_FALSE(root_delegated_shared_quad_state->is_clipped);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTestClip, QuadsClipped_LayerClipped_Surface) {
   root_delegated_render_pass_is_clipped_ = true;
   clip_delegated_renderer_layer_ = true;
   SetUpTest();
 
-  delegated_renderer_layer_->SetForceRenderSurface(true);
+  delegated_renderer_layer_->SetHasRenderSurface(true);
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
 
   ASSERT_EQ(3u, frame.render_passes.size());
   const QuadList& contrib_delegated_quad_list =
       frame.render_passes[0]->quad_list;
   ASSERT_EQ(2u, contrib_delegated_quad_list.size());
   const QuadList& root_delegated_quad_list = frame.render_passes[1]->quad_list;
   ASSERT_EQ(5u, root_delegated_quad_list.size());
@@ skipping 12 matching lines @@
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTest, InvalidRenderPassDrawQuad) {
   scoped_ptr<LayerImpl> root_layer = LayerImpl::Create(
       host_impl_->active_tree(), 1).PassAs<LayerImpl>();
   scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer =
       FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 4);
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
+  root_layer->SetHasRenderSurface(true);
 
   delegated_renderer_layer->SetPosition(gfx::Point(3, 3));
   delegated_renderer_layer->SetBounds(gfx::Size(10, 10));
   delegated_renderer_layer->SetContentBounds(gfx::Size(10, 10));
   delegated_renderer_layer->SetDrawsContent(true);
 
   RenderPassList delegated_render_passes;
   TestRenderPass* pass1 = AddRenderPass(&delegated_render_passes,
                                         RenderPassId(9, 6),
                                         gfx::Rect(0, 0, 10, 10),
@@ skipping 215 matching lines @@
   scoped_ptr<DelegatedRendererLayerImpl> other_layer =
       DelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 6);
 
   delegated_renderer_layer_impl->PushPropertiesTo(other_layer.get());
 
   EXPECT_EQ(0.5f, other_layer->inverse_device_scale_factor());
 }
 
 }  // namespace
 }  // namespace cc