1 files changed, 137 insertions, 49 deletions

diff --git a/chromium/cc/trees/layer_tree_host_unittest_masks.cc b/chromium/cc/trees/layer_tree_host_unittest_masks.cc
index 3a2edb4e411..ca119f3aa82 100644
--- a/chromium/cc/trees/layer_tree_host_unittest_masks.cc
+++ b/chromium/cc/trees/layer_tree_host_unittest_masks.cc
@@ -22,7 +22,9 @@ class LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOrigin
     // the surface bounds to be larger. It also has a parent that clips the
     // masked layer and its surface.
 
-    scoped_refptr<Layer> root = Layer::Create();
+    SetInitialRootBounds(gfx::Size(100, 100));
+    LayerTreeTest::SetupTree();
+    Layer* root = layer_tree_host()->root_layer();
 
     scoped_refptr<FakePictureLayer> content_layer =
         FakePictureLayer::Create(&client_);
@@ -42,27 +44,30 @@ class LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOrigin
             &client_, std::move(recording_source));
     content_layer->SetMaskLayer(mask_layer);
 
-    gfx::Size root_size(100, 100);
-    root->SetBounds(root_size);
-
     gfx::Size layer_size(100, 100);
     content_layer->SetBounds(layer_size);
 
     gfx::Size mask_size(100, 100);
     mask_layer->SetBounds(mask_size);
-    mask_layer->SetLayerMaskType(Layer::LayerMaskType::SINGLE_TEXTURE_MASK);
     mask_layer_id_ = mask_layer->id();
 
-    layer_tree_host()->SetRootLayer(root);
-    LayerTreeTest::SetupTree();
-    scoped_refptr<Layer> outer_viewport_scroll_layer = Layer::Create();
-    outer_viewport_scroll_layer->SetBounds(layer_size);
-    SetupViewport(root.get(), outer_viewport_scroll_layer, gfx::Size(50, 50));
-    layer_tree_host()->outer_viewport_container_layer()->SetMasksToBounds(true);
-    outer_viewport_scroll_layer->AddChild(content_layer);
+    scoped_refptr<Layer> clip_layer = Layer::Create();
+    clip_layer->SetBounds(gfx::Size(50, 50));
+    clip_layer->SetMasksToBounds(true);
+
+    scoped_refptr<Layer> scroll_layer = Layer::Create();
+    scroll_layer->SetBounds(layer_size);
+    scroll_layer->SetScrollable(gfx::Size(50, 50));
+    scroll_layer->SetMasksToBounds(true);
+    scroll_layer->SetElementId(
+        LayerIdToElementIdForTesting(scroll_layer->id()));
+
+    root->AddChild(clip_layer);
+    clip_layer->AddChild(scroll_layer);
+    scroll_layer->AddChild(content_layer);
 
     client_.set_bounds(root->bounds());
-    outer_viewport_scroll_layer->SetScrollOffset(gfx::ScrollOffset(50, 50));
+    scroll_layer->SetScrollOffset(gfx::ScrollOffset(50, 50));
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
@@ -70,7 +75,7 @@ class LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOrigin
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
-    EXPECT_EQ(2u, frame_data->render_passes.size());
+    EXPECT_EQ(3u, frame_data->render_passes.size());
     viz::RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
 
@@ -85,11 +90,13 @@ class LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOrigin
     gfx::Rect rect_in_target_space = MathUtil::MapEnclosingClippedRect(
         render_pass_quad->shared_quad_state->quad_to_target_transform,
         render_pass_quad->rect);
-    EXPECT_EQ(gfx::Rect(0, 0, 50, 50).ToString(),
-              rect_in_target_space.ToString());
-    EXPECT_EQ(gfx::ScaleRect(gfx::RectF(50.f, 50.f, 50.f, 50.f), 1.f / 100.f)
-                  .ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+    EXPECT_EQ(gfx::Rect(0, 0, 50, 50), rect_in_target_space);
+
+    // We use kDstIn blend mode instead of the mask feature of RenderPass.
+    EXPECT_EQ(gfx::RectF(), render_pass_quad->mask_uv_rect);
+    viz::RenderPass* mask_pass = frame_data->render_passes[1].get();
+    EXPECT_EQ(SkBlendMode::kDstIn,
+              mask_pass->quad_list.front()->shared_quad_state->blend_mode);
     EndTest();
     return draw_result;
   }
@@ -101,6 +108,88 @@ class LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOrigin
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOrigin);
 
+class LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOriginWithLayerList
+    : public LayerTreeTest {
+ protected:
+  LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOriginWithLayerList() {
+    SetUseLayerLists();
+  }
+
+  void SetupTree() override {
+    // The masked layer has bounds 50x50, but it has a child that causes
+    // the surface bounds to be larger. It also has a parent that clips the
+    // masked layer and its surface.
+
+    SetInitialRootBounds(gfx::Size(100, 100));
+    LayerTreeTest::SetupTree();
+
+    Layer* root = layer_tree_host()->root_layer();
+
+    gfx::Size layer_size(100, 100);
+    SetupViewport(root, gfx::Size(50, 50), layer_size);
+
+    auto* scroll = layer_tree_host()->OuterViewportScrollLayerForTesting();
+    SetScrollOffset(scroll, gfx::ScrollOffset(50, 50));
+
+    client_.set_bounds(root->bounds());
+    auto content_layer = FakePictureLayer::Create(&client_);
+    content_layer->SetBounds(layer_size);
+    CopyProperties(scroll, content_layer.get());
+    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();
+
+    auto mask_layer = FakePictureLayer::CreateWithRecordingSource(
+        &client_, std::move(recording_source));
+    SetupMaskProperties(content_layer.get(), mask_layer.get());
+    root->AddChild(mask_layer);
+
+    mask_layer_id_ = mask_layer->id();
+  }
+
+  void BeginTest() override { PostSetNeedsCommitToMainThread(); }
+
+  DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
+                                   LayerTreeHostImpl::FrameData* frame_data,
+                                   DrawResult draw_result) override {
+    EXPECT_EQ(1u, frame_data->render_passes.size());
+    viz::RenderPass* pass = frame_data->render_passes.back().get();
+    EXPECT_EQ(3u, pass->quad_list.size());
+
+    // There's a solid color quad under everything.
+    EXPECT_EQ(viz::DrawQuad::Material::kSolidColor,
+              pass->quad_list.back()->material);
+
+    EXPECT_EQ(viz::DrawQuad::Material::kTiledContent,
+              pass->quad_list.ElementAt(1)->material);
+
+    auto* mask_quad = pass->quad_list.front();
+    EXPECT_EQ(viz::DrawQuad::Material::kTiledContent, mask_quad->material);
+    gfx::Rect rect_in_target_space = MathUtil::MapEnclosingClippedRect(
+        mask_quad->shared_quad_state->quad_to_target_transform,
+        mask_quad->rect);
+    EXPECT_EQ(gfx::Rect(0, 0, 50, 50), rect_in_target_space);
+    // We use kDstIn blend mode for mask.
+    EXPECT_EQ(SkBlendMode::kDstIn, mask_quad->shared_quad_state->blend_mode);
+    EndTest();
+    return draw_result;
+  }
+
+  int mask_layer_id_;
+  FakeContentLayerClient client_;
+};
+
+SINGLE_AND_MULTI_THREAD_TEST_F(
+    LayerTreeTestMaskLayerForSurfaceWithContentRectNotAtOriginWithLayerList);
+
 class LayerTreeTestMaskLayerForSurfaceWithClippedLayer : public LayerTreeTest {
  protected:
   void SetupTree() override {
@@ -156,7 +245,6 @@ class LayerTreeTestMaskLayerForSurfaceWithClippedLayer : public LayerTreeTest {
 
     gfx::Size mask_size(50, 50);
     mask_layer->SetBounds(mask_size);
-    mask_layer->SetLayerMaskType(Layer::LayerMaskType::SINGLE_TEXTURE_MASK);
     mask_layer_id_ = mask_layer->id();
 
     layer_tree_host()->SetRootLayer(root);
@@ -169,7 +257,7 @@ class LayerTreeTestMaskLayerForSurfaceWithClippedLayer : public LayerTreeTest {
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
-    EXPECT_EQ(2u, frame_data->render_passes.size());
+    EXPECT_EQ(3u, frame_data->render_passes.size());
     viz::RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
 
@@ -187,13 +275,12 @@ class LayerTreeTestMaskLayerForSurfaceWithClippedLayer : public LayerTreeTest {
         render_pass_quad->rect);
     EXPECT_EQ(gfx::Rect(20, 10, 10, 20).ToString(),
               rect_in_target_space.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());
+
+    // We use kDstIn blend mode instead of the mask feature of RenderPass.
+    EXPECT_EQ(gfx::RectF(), render_pass_quad->mask_uv_rect);
+    viz::RenderPass* mask_pass = frame_data->render_passes[1].get();
+    EXPECT_EQ(SkBlendMode::kDstIn,
+              mask_pass->quad_list.front()->shared_quad_state->blend_mode);
     EndTest();
     return draw_result;
   }
@@ -265,7 +352,6 @@ class LayerTreeTestMaskLayerForSurfaceWithDifferentScale
 
     gfx::Size mask_size(50, 50);
     mask_layer->SetBounds(mask_size);
-    mask_layer->SetLayerMaskType(Layer::LayerMaskType::SINGLE_TEXTURE_MASK);
     // Setting will change transform on mask layer will make it not adjust
     // raster scale, which will remain 1. This means the mask_layer and render
     // surface will have a scale of 2 during draw time.
@@ -282,7 +368,7 @@ class LayerTreeTestMaskLayerForSurfaceWithDifferentScale
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
-    EXPECT_EQ(2u, frame_data->render_passes.size());
+    EXPECT_EQ(3u, frame_data->render_passes.size());
     viz::RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
 
@@ -306,13 +392,12 @@ class LayerTreeTestMaskLayerForSurfaceWithDifferentScale
         render_pass_quad->visible_rect);
     EXPECT_EQ(gfx::Rect(20, 10, 20, 40).ToString(),
               visible_rect_in_target_space.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());
+
+    // We use kDstIn blend mode instead of the mask feature of RenderPass.
+    EXPECT_EQ(gfx::RectF(), render_pass_quad->mask_uv_rect);
+    viz::RenderPass* mask_pass = frame_data->render_passes[1].get();
+    EXPECT_EQ(SkBlendMode::kDstIn,
+              mask_pass->quad_list.front()->shared_quad_state->blend_mode);
     EndTest();
     return draw_result;
   }
@@ -368,9 +453,7 @@ class LayerTreeTestMaskLayerWithScaling : public LayerTreeTest {
     scaling_layer->SetTransform(scale);
 
     content_layer->SetBounds(scaling_layer_size);
-
     mask_layer->SetBounds(scaling_layer_size);
-    mask_layer->SetLayerMaskType(Layer::LayerMaskType::SINGLE_TEXTURE_MASK);
 
     layer_tree_host()->SetRootLayer(root);
     LayerTreeTest::SetupTree();
@@ -382,7 +465,7 @@ class LayerTreeTestMaskLayerWithScaling : public LayerTreeTest {
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
-    EXPECT_EQ(2u, frame_data->render_passes.size());
+    EXPECT_EQ(3u, frame_data->render_passes.size());
     viz::RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
 
@@ -397,22 +480,25 @@ class LayerTreeTestMaskLayerWithScaling : public LayerTreeTest {
     gfx::Rect rect_in_target_space = MathUtil::MapEnclosingClippedRect(
         render_pass_quad->shared_quad_state->quad_to_target_transform,
         render_pass_quad->rect);
+
+    // We use kDstIn blend mode instead of the mask feature of RenderPass.
+    EXPECT_EQ(gfx::RectF(), render_pass_quad->mask_uv_rect);
+    viz::RenderPass* mask_pass = frame_data->render_passes[1].get();
+    EXPECT_EQ(SkBlendMode::kDstIn,
+              mask_pass->quad_list.front()->shared_quad_state->blend_mode);
+
     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(),
                   rect_in_target_space.ToString());
-        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(),
                   rect_in_target_space.ToString());
-        EXPECT_EQ(gfx::RectF(0.f, 0.f, 1.f, 1.f).ToString(),
-                  render_pass_quad->mask_uv_rect.ToString());
         EndTest();
         break;
     }
@@ -471,7 +557,6 @@ class LayerTreeTestMaskWithNonExactTextureSize : public LayerTreeTest {
     gfx::Size mask_size(100, 100);
     gfx::Size mask_texture_size(120, 150);
     mask_layer->SetBounds(mask_size);
-    mask_layer->SetLayerMaskType(Layer::LayerMaskType::SINGLE_TEXTURE_MASK);
     mask_layer->set_fixed_tile_size(mask_texture_size);
 
     layer_tree_host()->SetRootLayer(root);
@@ -484,7 +569,7 @@ class LayerTreeTestMaskWithNonExactTextureSize : public LayerTreeTest {
   DrawResult PrepareToDrawOnThread(LayerTreeHostImpl* host_impl,
                                    LayerTreeHostImpl::FrameData* frame_data,
                                    DrawResult draw_result) override {
-    EXPECT_EQ(2u, frame_data->render_passes.size());
+    EXPECT_EQ(3u, frame_data->render_passes.size());
     viz::RenderPass* root_pass = frame_data->render_passes.back().get();
     EXPECT_EQ(2u, root_pass->quad_list.size());
 
@@ -499,9 +584,12 @@ class LayerTreeTestMaskWithNonExactTextureSize : public LayerTreeTest {
         viz::RenderPassDrawQuad::MaterialCast(root_pass->quad_list.front());
     EXPECT_EQ(gfx::Rect(0, 0, 100, 100).ToString(),
               render_pass_quad->rect.ToString());
-    // The mask layer is 100x100, but is backed by a 120x150 image.
-    EXPECT_EQ(gfx::RectF(0.0f, 0.0f, 100.f / 120.0f, 100.f / 150.0f).ToString(),
-              render_pass_quad->mask_uv_rect.ToString());
+
+    // We use kDstIn blend mode instead of the mask feature of RenderPass.
+    EXPECT_EQ(gfx::RectF(), render_pass_quad->mask_uv_rect);
+    viz::RenderPass* mask_pass = frame_data->render_passes[1].get();
+    EXPECT_EQ(SkBlendMode::kDstIn,
+              mask_pass->quad_list.front()->shared_quad_state->blend_mode);
     EndTest();
     return draw_result;
   }