cc: RenderSurfaceImpl tile mask layer.

cc/trees/layer_tree_host_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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 6550 matching lines @@
     root->AddChild(clipping_layer);
 
     scoped_refptr<FakePictureLayer> content_layer =
         FakePictureLayer::Create(&client_);
     clipping_layer->AddChild(content_layer);
 
     scoped_refptr<FakePictureLayer> content_child_layer =
         FakePictureLayer::Create(&client_);
     content_layer->AddChild(content_child_layer);
 
+    std::unique_ptr<RecordingSource> recording_source =
+        FakeRecordingSource::CreateFilledRecordingSource(gfx::Size(100, 100));
+    PaintFlags paint1, paint2;
+    static_cast<FakeRecordingSource*>(recording_source.get())
+        ->add_draw_rect_with_flags(gfx::Rect(0, 0, 100, 90), paint1);
+    static_cast<FakeRecordingSource*>(recording_source.get())
+        ->add_draw_rect_with_flags(gfx::Rect(0, 90, 100, 10), paint2);
+    client_.set_fill_with_nonsolid_color(true);
+    static_cast<FakeRecordingSource*>(recording_source.get())->Rerecord();
+
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::CreateWithRecordingSource(
+            &client_, std::move(recording_source));
     content_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::PointF clipping_origin(20.f, 10.f);
     gfx::Size clipping_size(10, 20);
     clipping_layer->SetBounds(clipping_size);
     clipping_layer->SetPosition(clipping_origin);
     clipping_layer->SetMasksToBounds(true);
@@ skipping 31 matching lines @@
     // The surface is clipped to 10x20.
     EXPECT_EQ(DrawQuad::RENDER_PASS, root_pass->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(root_pass->quad_list.front());
     EXPECT_EQ(gfx::Rect(20, 10, 10, 20).ToString(),
               render_pass_quad->rect.ToString());
     // The masked layer is 50x50, but the surface size is 10x20. So the texture
     // coords in the mask are scaled by 10/50 and 20/50.
     // The surface is clipped to (20,10) so the mask texture coords are offset
     // by 20/50 and 10/50
-    EXPECT_EQ(gfx::ScaleRect(gfx::RectF(20.f, 10.f, 10.f, 20.f), 1.f / 50.f)
-                  .ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+    if (host_impl->settings().enable_mask_tiling) {

[enne (OOO), 2017/03/28 14:10:22]

Hmm.  What's the end state of mask tiling?  I assume this setting will go away
and always be true.  Are we going to keep the mask_type_ in PictureLayerImpl,
such that some mask layers will be single tile and others will be tiled based on
some criteria?

Mostly I'm asking because I'm wondering if this should really be two tests
(because we'll have tiled and untiled in the future) or if this is just code
that will get cleaned up when the setting flips.

[sunxd, 2017/03/29 16:00:24]

The flag is going away once we fix the AA and filter-demoting bugs.
But we will have two kinds of masks: tiled one and single texture one (because
of filters).

[enne (OOO), 2017/03/29 16:07:25]

Ok, then it sounds like we needs two kinds of tests.  Can you make these tests
test both with and without tiled masks?  Additionally, can you make all of the
mask pixel tests test with and without tiled masks?

[sunxd, 2017/03/30 13:56:37]

I can, but the flag will go away shortly. Single texture masks only exist if we
have a filter in that world. I think probably I should add tests that has a
filter applied to the mask?

[sunxd, 2017/04/04 13:58:04]

As this change blocks AA patch, can I write the tests in another patch?

+      EXPECT_EQ(
+          gfx::RectF(20.f / 128.f, 10.f / 128.f, 10.f / 128.f, 20.f / 128.f)

[enne (OOO), 2017/03/28 14:10:22]

Where does 128 come from? I'm guessing that's rounding up to multiples of 64 for
tile size? Can you make this based on the tile size itself, so that when we
change tile size, this test won't break?

[sunxd, 2017/03/29 16:00:24]

It's an unchecked round up with 64. While 64 is defined as kTileRoundUp in
picture_layer_impl.cc, I think we are not able to access this number in cc unit
tests, maybe we need to write it as UncheckedRoundUp(mask_size, 64)?

[enne (OOO), 2017/03/29 16:07:25]

Can you make this based on the resource size, or something? I just want a test
that doesn't fail when PictureLayerImpl changes.

[sunxd, 2017/03/30 13:56:37]

Done.

+              .ToString(),
+          render_pass_quad->mask_uv_rect.ToString());
+    } else {
+      EXPECT_EQ(gfx::ScaleRect(gfx::RectF(20.f, 10.f, 10.f, 20.f), 1.f / 50.f)
+                    .ToString(),
+                render_pass_quad->mask_uv_rect.ToString());
+    }
     EndTest();
     return draw_result;
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 15 matching lines @@
 
     scoped_refptr<Layer> root = Layer::Create();
 
     scoped_refptr<Layer> scaling_layer = Layer::Create();
     root->AddChild(scaling_layer);
 
     scoped_refptr<FakePictureLayer> content_layer =
         FakePictureLayer::Create(&client_);
     scaling_layer->AddChild(content_layer);
 
+    std::unique_ptr<RecordingSource> recording_source =
+        FakeRecordingSource::CreateFilledRecordingSource(gfx::Size(100, 100));
+    PaintFlags paint1, paint2;
+    static_cast<FakeRecordingSource*>(recording_source.get())
+        ->add_draw_rect_with_flags(gfx::Rect(0, 0, 100, 10), paint1);
+    static_cast<FakeRecordingSource*>(recording_source.get())
+        ->add_draw_rect_with_flags(gfx::Rect(0, 10, 100, 90), paint2);
+    client_.set_fill_with_nonsolid_color(true);
+    static_cast<FakeRecordingSource*>(recording_source.get())->Rerecord();
+
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::CreateWithRecordingSource(
+            &client_, std::move(recording_source));
     content_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size scaling_layer_size(50, 50);
     scaling_layer->SetBounds(scaling_layer_size);
     gfx::Transform scale;
     scale.Scale(2.f, 2.f);
     scaling_layer->SetTransform(scale);
@@ skipping 22 matching lines @@
 
     EXPECT_EQ(DrawQuad::RENDER_PASS, root_pass->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(root_pass->quad_list.front());
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // Check that the tree scaling is correctly taken into account for the
         // mask, that should fully map onto the quad.
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
                   render_pass_quad->rect.ToString());
-        EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-                  render_pass_quad->mask_uv_rect.ToString());
+        if (host_impl->settings().enable_mask_tiling) {
+          EXPECT_EQ(
+              gfx::RectF(0.f, 0.f, 100.f / 128.f, 100.f / 128.f).ToString(),

[enne (OOO), 2017/03/28 14:10:22]

Are there any unit tests that have multiple mask tiles?

And cc pixel tests are all using this tiled mask path already, right?

[sunxd, 2017/03/29 16:00:24]

I think this test is testing multiple tiles if the flag is enabled.

I'll enable this flag for cc tests.

[enne (OOO), 2017/03/29 16:07:25]

As I said above, can you make it work with both kinds of mask types, regardless
of whether the flag is on?

[sunxd, 2017/03/30 13:56:37]

Acknowledged.

+              render_pass_quad->mask_uv_rect.ToString());
+        } else {
+          EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
+                    render_pass_quad->mask_uv_rect.ToString());
+        }
         break;
       case 1:
         // Applying a DSF should change the render surface size, but won't
         // affect which part of the mask is used.
         EXPECT_EQ(gfx::Rect(0, 0, 200, 200).ToString(),
                   render_pass_quad->rect.ToString());
-        EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-                  render_pass_quad->mask_uv_rect.ToString());
+        if (host_impl->settings().enable_mask_tiling) {
+          EXPECT_EQ(
+              gfx::RectF(0.f, 0.f, 100.f / 128.f, 100.f / 128.f).ToString(),
+              render_pass_quad->mask_uv_rect.ToString());
+        } else {
+          EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
+                    render_pass_quad->mask_uv_rect.ToString());
+        }
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         gfx::Size double_root_size(200, 200);
@@ skipping 15 matching lines @@
   void SetupTree() override {
     // The mask layer has bounds 100x100 but is attached to a layer with bounds
     // 50x50.
 
     scoped_refptr<Layer> root = Layer::Create();
 
     scoped_refptr<FakePictureLayer> content_layer =
         FakePictureLayer::Create(&client_);
     root->AddChild(content_layer);
 
+    std::unique_ptr<RecordingSource> recording_source =
+        FakeRecordingSource::CreateFilledRecordingSource(gfx::Size(100, 100));
+    PaintFlags paint1, paint2;
+    static_cast<FakeRecordingSource*>(recording_source.get())
+        ->add_draw_rect_with_flags(gfx::Rect(0, 0, 100, 90), paint1);
+    static_cast<FakeRecordingSource*>(recording_source.get())
+        ->add_draw_rect_with_flags(gfx::Rect(0, 90, 100, 10), paint2);
+    client_.set_fill_with_nonsolid_color(true);
+    static_cast<FakeRecordingSource*>(recording_source.get())->Rerecord();
+
     scoped_refptr<FakePictureLayer> mask_layer =
-        FakePictureLayer::Create(&client_);
+        FakePictureLayer::CreateWithRecordingSource(
+            &client_, std::move(recording_source));
     content_layer->SetMaskLayer(mask_layer.get());
 
     gfx::Size root_size(100, 100);
     root->SetBounds(root_size);
 
     gfx::Size layer_size(50, 50);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
@@ skipping 17 matching lines @@
     EXPECT_EQ(DrawQuad::SOLID_COLOR, root_pass->quad_list.back()->material);
 
     EXPECT_EQ(DrawQuad::RENDER_PASS, root_pass->quad_list.front()->material);
     const RenderPassDrawQuad* render_pass_quad =
         RenderPassDrawQuad::MaterialCast(root_pass->quad_list.front());
     switch (host_impl->active_tree()->source_frame_number()) {
       case 0:
         // Check that the mask fills the surface.
         EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
                   render_pass_quad->rect.ToString());
-        EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-                  render_pass_quad->mask_uv_rect.ToString());
+        if (host_impl->settings().enable_mask_tiling) {
+          EXPECT_EQ(gfx::RectF(0.f, 0.f, 50.f / 128.f, 50.f / 128.f).ToString(),
+                    render_pass_quad->mask_uv_rect.ToString());
+        } else {
+          EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
+                    render_pass_quad->mask_uv_rect.ToString());
+        }
         break;
       case 1:
         // Applying a DSF should change the render surface size, but won't
         // affect which part of the mask is used.
         EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
                   render_pass_quad->rect.ToString());
-        EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-                  render_pass_quad->mask_uv_rect.ToString());
+        if (host_impl->settings().enable_mask_tiling) {
+          EXPECT_EQ(gfx::RectF(0.f, 0.f, 50.f / 128.f, 50.f / 128.f).ToString(),
+                    render_pass_quad->mask_uv_rect.ToString());
+        } else {
+          EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
+                    render_pass_quad->mask_uv_rect.ToString());
+        }
         EndTest();
         break;
     }
     return draw_result;
   }
 
   void DidCommit() override {
     switch (layer_tree_host()->SourceFrameNumber()) {
       case 1:
         gfx::Size double_root_size(200, 200);
@@ skipping 521 matching lines @@
     DCHECK_EQ(hud->scroll_tree_index(), root_layer->scroll_tree_index());
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestHudLayerWithLayerLists);
 
 }  // namespace
 }  // namespace cc