Apply the correct transform_to_root_target DelegatedRendererLayerImpl::AppendRenderPassQuads().

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 1356 matching lines @@
   EXPECT_EQ(DrawQuad::SOLID_COLOR,
             frame.render_passes[0]->quad_list[0]->material);
 
   host_impl_->DrawLayers(&frame, gfx::FrameTime::Now());
   host_impl_->DidDrawAllLayers(frame);
 }
 
 TEST_F(DelegatedRendererLayerImplTest, Occlusion) {
   gfx::Size layer_size(1000, 1000);
   gfx::Size viewport_size(1000, 1000);
-  gfx::Rect quad_rect(200, 300, 400, 500);
+  gfx::Rect quad_screen_rect(211, 300, 400, 500);
 
   gfx::Transform transform;
-  transform.Translate(11.0, 0.0);
+  transform.Translate(211.0, 300.0);
 
   LayerTestCommon::LayerImplTest impl;
 
   FakeDelegatedRendererLayerImpl* delegated_renderer_layer_impl =
       impl.AddChildToRoot<FakeDelegatedRendererLayerImpl>();
   delegated_renderer_layer_impl->SetBounds(layer_size);
   delegated_renderer_layer_impl->SetContentBounds(layer_size);
   delegated_renderer_layer_impl->SetDrawsContent(true);
 
+  // Contributing render pass is offset by a transform and holds a quad that
+  // covers it entirely.
   RenderPassList delegated_render_passes;
   // pass2 is just the size of the quad. It contributes to |pass1| with a
-  // translation of (11,0).
+  // translation of (211,300).
   RenderPassId pass2_id =
       delegated_renderer_layer_impl->FirstContributingRenderPassId();
-  TestRenderPass* pass2 =
-      AddRenderPass(&delegated_render_passes, pass2_id, quad_rect, transform);
-  AddQuad(pass2, gfx::Rect(quad_rect.size()), SK_ColorRED);
+  TestRenderPass* pass2 = AddRenderPass(&delegated_render_passes,
+                                        pass2_id,
+                                        gfx::Rect(quad_screen_rect.size()),
+                                        transform);
+  AddQuad(pass2, gfx::Rect(quad_screen_rect.size()), SK_ColorRED);
   // |pass1| covers the whole layer.
   RenderPassId pass1_id = RenderPassId(impl.root_layer()->id(), 0);
   TestRenderPass* pass1 = AddRenderPass(&delegated_render_passes,
                                         pass1_id,
                                         gfx::Rect(layer_size),
                                         gfx::Transform());
   AddRenderPassQuad(pass1, pass2, 0, FilterOperations(), transform);
   delegated_renderer_layer_impl->SetFrameDataForRenderPasses(
       1.f, &delegated_render_passes);
 
   impl.CalcDrawProps(viewport_size);
 
-  // The |quad_rect| translated by the |transform|.
-  gfx::Rect quad_screen_rect = quad_rect + gfx::Vector2d(11, 0);
-
   {
     SCOPED_TRACE("No occlusion");
     gfx::Rect occluded;
 
     {
       SCOPED_TRACE("Root render pass");
       impl.AppendQuadsForPassWithOcclusion(
           delegated_renderer_layer_impl, pass1_id, occluded);
       LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
                                                    quad_screen_rect);
       ASSERT_EQ(1u, impl.quad_list().size());
       EXPECT_EQ(DrawQuad::RENDER_PASS, impl.quad_list()[0]->material);
     }
     {
       SCOPED_TRACE("Contributing render pass");
       impl.AppendQuadsForPassWithOcclusion(
           delegated_renderer_layer_impl, pass2_id, occluded);
-      LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
-                                                   gfx::Rect(quad_rect.size()));
+      LayerTestCommon::VerifyQuadsExactlyCoverRect(
+          impl.quad_list(), gfx::Rect(quad_screen_rect.size()));
       ASSERT_EQ(1u, impl.quad_list().size());
       EXPECT_EQ(DrawQuad::SOLID_COLOR, impl.quad_list()[0]->material);
     }
   }
 
   {
     SCOPED_TRACE("Full occlusion");
     {
       gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
 
       SCOPED_TRACE("Root render pass");
       impl.AppendQuadsForPassWithOcclusion(
           delegated_renderer_layer_impl, pass1_id, occluded);
       LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
                                                    gfx::Rect());
       EXPECT_EQ(impl.quad_list().size(), 0u);
     }
     {
       gfx::Rect occluded(delegated_renderer_layer_impl->visible_content_rect());
-      // Move the occlusion to where it is in the contributing surface.
-      occluded -= quad_rect.OffsetFromOrigin();
 
       SCOPED_TRACE("Contributing render pass");
       impl.AppendQuadsForPassWithOcclusion(
           delegated_renderer_layer_impl, pass2_id, occluded);
       LayerTestCommon::VerifyQuadsExactlyCoverRect(impl.quad_list(),
                                                    gfx::Rect());
       EXPECT_EQ(impl.quad_list().size(), 0u);
     }
   }
 
   {
     SCOPED_TRACE("Partial occlusion");
     {
-      gfx::Rect occluded(0, 0, 500, 1000);
+      gfx::Rect occlusion_in_root_target(0, 0, 500, 1000);
 
       SCOPED_TRACE("Root render pass");
       impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass1_id, occluded);
+          delegated_renderer_layer_impl, pass1_id, occlusion_in_root_target);
       size_t partially_occluded_count = 0;
-      LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
-          impl.quad_list(),
-          quad_screen_rect,
-          occluded,
-          &partially_occluded_count);
+      LayerTestCommon::VerifyQuadsAreOccluded(impl.quad_list(),
+                                              occlusion_in_root_target,
+                                              &partially_occluded_count);
       // The layer outputs one quad, which is partially occluded.
       EXPECT_EQ(1u, impl.quad_list().size());
       EXPECT_EQ(1u, partially_occluded_count);
     }
     {
-      gfx::Rect occluded(0, 0, 500, 1000);
+      gfx::Rect occlusion_in_root_target(0, 0, 500, 1000);
       // Move the occlusion to where it is in the contributing surface.
-      occluded -= quad_rect.OffsetFromOrigin() + gfx::Vector2d(11, 0);
+      gfx::Rect occlusion_in_target_of_delegated_quad =
+          occlusion_in_root_target - quad_screen_rect.OffsetFromOrigin();
 
       SCOPED_TRACE("Contributing render pass");
       impl.AppendQuadsForPassWithOcclusion(
-          delegated_renderer_layer_impl, pass2_id, occluded);
+          delegated_renderer_layer_impl, pass2_id, occlusion_in_root_target);
       size_t partially_occluded_count = 0;
-      LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
+      LayerTestCommon::VerifyQuadsAreOccluded(
           impl.quad_list(),
-          gfx::Rect(quad_rect.size()),
-          occluded,
+          occlusion_in_target_of_delegated_quad,
           &partially_occluded_count);
       // The layer outputs one quad, which is partially occluded.
       EXPECT_EQ(1u, impl.quad_list().size());
       EXPECT_EQ(1u, partially_occluded_count);
       // The quad in the contributing surface is at (211,300) in the root.
       // The occlusion extends to 500 in the x-axis, pushing the left of the
       // visible part of the quad to 500 - 211 = 300 - 11 inside the quad.
       EXPECT_EQ(gfx::Rect(300 - 11, 0, 100 + 11, 500).ToString(),
                 impl.quad_list()[0]->visible_rect.ToString());
     }
-  }
-  {
-    gfx::Rect occluded(0, 0, 500, 1000);
-    // Move the occlusion to where it is in the contributing surface.
-    occluded -= quad_rect.OffsetFromOrigin() + gfx::Vector2d(11, 0);
+    {
+      gfx::Rect occlusion_in_root_target(0, 0, 500, 1000);
+      // Move the occlusion to where it is in the contributing surface.
+      gfx::Rect occlusion_in_target_of_delegated_quad =
+          occlusion_in_root_target - quad_screen_rect.OffsetFromOrigin();
 
-    SCOPED_TRACE("Contributing render pass with transformed root");
+      SCOPED_TRACE("Contributing render pass with transformed root");
 
-    delegated_renderer_layer_impl->SetTransform(transform);
-    impl.CalcDrawProps(viewport_size);
+      gfx::Transform layer_transform;
+      layer_transform.Translate(11.0, 0.0);
+      delegated_renderer_layer_impl->SetTransform(layer_transform);
 
-    impl.AppendQuadsForPassWithOcclusion(
-        delegated_renderer_layer_impl, pass2_id, occluded);
-    size_t partially_occluded_count = 0;
-    LayerTestCommon::VerifyQuadsCoverRectWithOcclusion(
-        impl.quad_list(),
-        gfx::Rect(quad_rect.size()),
-        occluded,
-        &partially_occluded_count);
-    // The layer outputs one quad, which is partially occluded.
-    EXPECT_EQ(1u, impl.quad_list().size());
-    EXPECT_EQ(1u, partially_occluded_count);
-    // The quad in the contributing surface is at (222,300) in the transformed
-    // root. The occlusion extends to 500 in the x-axis, pushing the left of the
-    // visible part of the quad to 500 - 222 = 300 - 22 inside the quad.
-    EXPECT_EQ(gfx::Rect(300 - 22, 0, 100 + 22, 500).ToString(),
-              impl.quad_list()[0]->visible_rect.ToString());
+      occlusion_in_target_of_delegated_quad += gfx::Vector2d(11, 0);
+
+      impl.CalcDrawProps(viewport_size);
+
+      impl.AppendQuadsForPassWithOcclusion(
+          delegated_renderer_layer_impl, pass2_id, occlusion_in_root_target);
+      size_t partially_occluded_count = 0;
+      LayerTestCommon::VerifyQuadsAreOccluded(
+          impl.quad_list(),
+          occlusion_in_target_of_delegated_quad,
+          &partially_occluded_count);
+      // The layer outputs one quad, which is partially occluded.
+      EXPECT_EQ(1u, impl.quad_list().size());
+      EXPECT_EQ(1u, partially_occluded_count);
+      // The quad in the contributing surface is at (222,300) in the transformed
+      // root. The occlusion extends to 500 in the x-axis, pushing the left of
+      // the visible part of the quad to 500 - 222 = 300 - 22 inside the quad.
+      EXPECT_EQ(gfx::Rect(300 - 22, 0, 100 + 22, 500).ToString(),
+                impl.quad_list()[0]->visible_rect.ToString());
+    }
   }
 }
 
 TEST_F(DelegatedRendererLayerImplTest, PushPropertiesTo) {
   gfx::Size layer_size(1000, 1000);
 
   scoped_ptr<FakeDelegatedRendererLayerImpl> delegated_renderer_layer_impl =
       FakeDelegatedRendererLayerImpl::Create(host_impl_->active_tree(), 5);
   delegated_renderer_layer_impl->SetBounds(layer_size);
   delegated_renderer_layer_impl->SetContentBounds(layer_size);
@@ skipping 13 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