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 1375 matching lines @@
   delegated_renderer_layer_impl->SetBounds(layer_size);
   delegated_renderer_layer_impl->SetContentBounds(layer_size);
   delegated_renderer_layer_impl->SetDrawsContent(true);
 
   RenderPassList delegated_render_passes;
   // pass2 is just the size of the quad. It contributes to |pass1| with a
   // translation of (11,0).
   RenderPassId pass2_id =
       delegated_renderer_layer_impl->FirstContributingRenderPassId();
   TestRenderPass* pass2 =
       AddRenderPass(&delegated_render_passes, pass2_id, quad_rect, transform);

[danakj, 2014/09/09 19:16:34]

and this should be gfx::Rect(11, 0, 899, 1000) instead of quad_rect

then the transform matches the rect. and you get a quad at 200,300 inside the
surface which is offset by 11, putting the quad at 211,300 on the screen.

   AddQuad(pass2, gfx::Rect(quad_rect.size()), SK_ColorRED);

[danakj, 2014/09/09 19:16:34]

i think this should be quad_rect instead of dropping the offset

   // |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);
 
@@ skipping 66 matching lines @@
           quad_screen_rect,
           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);
     }
     {
       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);
+      occluded -= quad_screen_rect.OffsetFromOrigin();
 
       SCOPED_TRACE("Contributing render pass");
       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 (211,300) in the root.
+      // The quad in the contributing surface is at (222,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(),
+      // 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());
     }
   }
   {
     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);
 
     SCOPED_TRACE("Contributing render pass with transformed root");
 
     delegated_renderer_layer_impl->SetTransform(transform);
     impl.CalcDrawProps(viewport_size);
 
     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
+    // The quad in the contributing surface is at (233,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(),
+    // visible part of the quad to 500 - 233 = 300 - 33 inside the quad.
+    EXPECT_EQ(gfx::Rect(300 - 33, 0, 100 + 33, 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);
@@ skipping 14 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