cc: RenderSurfaceImpl tile mask layer.

cc/layers/render_surface_impl.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/layers/render_surface_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "cc/base/filter_operations.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/debug_colors.h"
+#include "cc/layers/append_quads_data.h"
 #include "cc/layers/layer_impl.h"
+#include "cc/quads/content_draw_quad_base.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
+#include "cc/quads/solid_color_draw_quad.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/effect_node.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion.h"
 #include "cc/trees/transform_node.h"
 #include "third_party/skia/include/core/SkImageFilter.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/transform.h"
 
@@ skipping 359 matching lines @@
   if (layer_tree_impl_->debug_state().show_debug_borders) {
     DebugBorderDrawQuad* debug_border_quad =
         render_pass->CreateAndAppendDrawQuad<DebugBorderDrawQuad>();
     debug_border_quad->SetNew(shared_quad_state, content_rect(),
                               visible_layer_rect, GetDebugBorderColor(),
                               GetDebugBorderWidth());
   }
 
   ResourceId mask_resource_id = 0;
   gfx::Size mask_texture_size;
-  gfx::Vector2dF mask_uv_scale;
+  gfx::RectF mask_uv_rect;
   gfx::Vector2dF surface_contents_scale =
       OwningEffectNode()->surface_contents_scale;
-  LayerImpl* mask_layer = MaskLayer();
+  PictureLayerImpl* mask_layer = static_cast<PictureLayerImpl*>(MaskLayer());
   if (mask_layer && mask_layer->DrawsContent() &&
       !mask_layer->bounds().IsEmpty()) {
     // The software renderer applies mask layer and blending in the wrong
     // order but kDstIn doesn't commute with masking. It is okay to not
     // support this configuration because kDstIn was introduced to replace
     // mask layers.
     DCHECK(BlendMode() != SkBlendMode::kDstIn)
         << "kDstIn blend mode with mask layer is unsupported.";
+    if (mask_layer->mask_type() == Layer::LayerMaskType::MULTI_TEXTURE_MASK) {
+      TileMaskLayer(render_pass, shared_quad_state, visible_layer_rect);
+      return;
+    }
     mask_layer->GetContentsResourceId(&mask_resource_id, &mask_texture_size);
     gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
         gfx::SizeF(OwningEffectNode()->unscaled_mask_target_size),
         surface_contents_scale.x(), surface_contents_scale.y());
-    mask_uv_scale = gfx::Vector2dF(1.0f / unclipped_mask_target_size.width(),
-                                   1.0f / unclipped_mask_target_size.height());
+    // Convert content_rect from target space to normalized space.
+    // Where unclipped_mask_target_size maps to gfx::Size(1, 1).
+    mask_uv_rect = gfx::ScaleRect(gfx::RectF(content_rect()),
+                                  1.0f / unclipped_mask_target_size.width(),
+                                  1.0f / unclipped_mask_target_size.height());
   }
 
+  gfx::RectF tex_coord_rect(0, 0, content_rect().width(),

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

nit: could just be tex_coord_rect(content_rect().size())

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

Done.

+                            content_rect().height());
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
-  quad->SetNew(
-      shared_quad_state, content_rect(), visible_layer_rect, GetRenderPassId(),
-      mask_resource_id, gfx::ScaleRect(gfx::RectF(content_rect()),
-                                       mask_uv_scale.x(), mask_uv_scale.y()),
-      mask_texture_size, surface_contents_scale, FiltersOrigin(), gfx::RectF());
+  quad->SetNew(shared_quad_state, content_rect(), visible_layer_rect,
+               GetRenderPassId(), mask_resource_id, mask_uv_rect,
+               mask_texture_size, surface_contents_scale, FiltersOrigin(),
+               tex_coord_rect);
+}
+
+void RenderSurfaceImpl::TileMaskLayer(RenderPass* render_pass,
+                                      SharedQuadState* shared_quad_state,
+                                      const gfx::Rect& visible_layer_rect) {
+  DCHECK(MaskLayer());
+  DCHECK(Filters().IsEmpty());
+
+  LayerImpl* mask_layer = MaskLayer();
+  gfx::Vector2dF owning_layer_to_surface_contents_scale =
+      OwningEffectNode()->surface_contents_scale;
+  std::unique_ptr<RenderPass> temp_render_pass = RenderPass::Create();
+  AppendQuadsData temp_append_quads_data;
+  mask_layer->AppendQuads(temp_render_pass.get(), &temp_append_quads_data);
+
+  auto* temp_quad = temp_render_pass->quad_list.front();
+  if (!temp_quad)
+    return;
+  gfx::Transform mask_quad_to_surface_contents =
+      temp_quad->shared_quad_state->quad_to_target_transform;
+  // Draw transform of a mask layer should be a 2d scale.
+  DCHECK(mask_quad_to_surface_contents.IsScale2d());
+  gfx::Vector2dF mask_quad_to_surface_contents_scale =
+      mask_quad_to_surface_contents.Scale2d();
+  shared_quad_state->quad_to_target_transform.matrix().preScale(
+      mask_quad_to_surface_contents_scale.x(),
+      mask_quad_to_surface_contents_scale.y(), 1.f);
+  shared_quad_state->quad_layer_bounds =
+      gfx::ScaleToCeiledSize(shared_quad_state->quad_layer_bounds,
+                             1.f / mask_quad_to_surface_contents_scale.x(),
+                             1.f / mask_quad_to_surface_contents_scale.y());
+  shared_quad_state->visible_quad_layer_rect = gfx::ToEnclosedRect(

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

gfx::ScaleToEnclosingRect, here and elsewhere

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

Done.

+      gfx::ScaleRect(gfx::RectF(shared_quad_state->visible_quad_layer_rect),
+                     mask_quad_to_surface_contents_scale.x(),
+                     mask_quad_to_surface_contents_scale.y()));
+  gfx::Rect content_rect_in_coverage_space = gfx::ToEnclosedRect(gfx::ScaleRect(
+      gfx::RectF(content_rect()), 1.f / mask_quad_to_surface_contents_scale.x(),
+      1.f / mask_quad_to_surface_contents_scale.y()));
+  gfx::Rect visible_layer_rect_in_coverage_space = gfx::ToEnclosedRect(
+      gfx::ScaleRect(gfx::RectF(visible_layer_rect),
+                     1.f / mask_quad_to_surface_contents_scale.x(),
+                     1.f / mask_quad_to_surface_contents_scale.y()));
+
+  for (auto* temp_quad : temp_render_pass->quad_list) {
+    gfx::Rect quad_rect = temp_quad->rect;
+    gfx::Rect render_quad_rect = quad_rect;
+    if (!quad_rect.Intersects(content_rect_in_coverage_space))
+      continue;
+    render_quad_rect =
+        gfx::IntersectRects(quad_rect, content_rect_in_coverage_space);
+    gfx::RectF quad_rect_in_surface_contents_space = gfx::ScaleRect(
+        gfx::RectF(render_quad_rect), mask_quad_to_surface_contents_scale.x(),
+        mask_quad_to_surface_contents_scale.y());
+    gfx::RectF quad_rect_in_non_normalized_texture_space =
+        quad_rect_in_surface_contents_space;
+    quad_rect_in_non_normalized_texture_space.Offset(
+        -content_rect().OffsetFromOrigin());

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

Is this logic with a content rect not at the origin tested?

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

It's tested in
LayoutTests/compositing/overflow/mask-with-small-content-rect.html

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

Can you add a cc unit test? I don't think layou tests are really the right place
to test that sort of detail.

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

I'll work on this on a separate patch just because I need some time to learn how
to write a pixel unit test.

[enne (OOO), 2017/03/30 14:36:52]

I think this detail here about the content rect not at the origin can just be a
unit test and not a pixel test.

Also, I think running the existing mask pixel tests (in
layer_tree_host_pixeltest_masks.cc) through both paths of single texture and
tiled would be good.  And one test like MaskOfLayer with a mask that's large
enough to have more than one tile show up in the pixel output.  If you have any
questions about cc pixel tests, I'm happy to help.  :)

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

Done.

+
+    switch (temp_quad->material) {
+      case DrawQuad::TILED_CONTENT: {
+        DCHECK_EQ(1U, temp_quad->resources.count);
+        RenderPassDrawQuad* quad =
+            render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
+
+        gfx::Size mask_texture_size =
+            static_cast<ContentDrawQuadBase*>(temp_quad)->texture_size;
+        gfx::RectF temp_tex_coord_rect =
+            static_cast<ContentDrawQuadBase*>(temp_quad)->tex_coord_rect;
+        gfx::Transform coverage_to_non_normalized_mask =
+            gfx::Transform(SkMatrix44(SkMatrix::MakeRectToRect(
+                RectToSkRect(quad_rect), RectFToSkRect(temp_tex_coord_rect),
+                SkMatrix::kFill_ScaleToFit)));
+        gfx::Transform coverage_to_normalized_mask =
+            coverage_to_non_normalized_mask;
+        coverage_to_normalized_mask.matrix().postScale(
+            1.f / mask_texture_size.width(), 1.f / mask_texture_size.height(),
+            1.f);
+        gfx::RectF mask_uv_rect = gfx::RectF(render_quad_rect);
+        coverage_to_normalized_mask.TransformRect(&mask_uv_rect);
+
+        quad->SetNew(shared_quad_state, render_quad_rect,
+                     gfx::IntersectRects(temp_quad->visible_rect,
+                                         visible_layer_rect_in_coverage_space),
+                     GetRenderPassId(), temp_quad->resources.ids[0],
+                     mask_uv_rect, mask_texture_size,
+                     owning_layer_to_surface_contents_scale, FiltersOrigin(),
+                     quad_rect_in_non_normalized_texture_space);
+      } break;
+      case DrawQuad::SOLID_COLOR: {
+        if (!static_cast<SolidColorDrawQuad*>(temp_quad)->color)
+          continue;
+        SkAlpha solid = SK_AlphaOPAQUE;
+        DCHECK_EQ(
+            SkColorGetA(static_cast<SolidColorDrawQuad*>(temp_quad)->color),
+            solid);
+        RenderPassDrawQuad* quad =
+            render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
+        quad->SetNew(shared_quad_state, render_quad_rect,
+                     gfx::IntersectRects(temp_quad->visible_rect,
+                                         visible_layer_rect_in_coverage_space),
+                     GetRenderPassId(), 0, gfx::RectF(), gfx::Size(),
+                     owning_layer_to_surface_contents_scale, FiltersOrigin(),
+                     quad_rect_in_non_normalized_texture_space);
+      } break;
+      case DrawQuad::DEBUG_BORDER:
+        NOTIMPLEMENTED();
+        break;
+      default:
+        NOTREACHED();
+        break;
+    }
+  }
 }
 
 }  // namespace cc