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/math_util.h"
 #include "cc/debug/debug_colors.h"
+#include "cc/layers/append_quads_data.h"
 #include "cc/layers/layer_impl.h"
 #include "cc/layers/render_pass_sink.h"
 #include "cc/output/filter_operations.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 357 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());
   }
 
   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(),
+               gfx::RectF());

[sunxd, 2017/03/08 19:57:46]

In https://codereview.chromium.org/2716893002/, enne@ suggested keeping all tex
rect logic either in the renderer or render surface impl.

As we need to deal with multiple spaces when computing tex coord rect for a
tiled mask, I think at least in this case the logic should reside in render
surface impl.

However, in other cases (no mask or mask not tilable), the tex rect is set as a
result of ApplyImageFilter in the renderers, I'm not sure if we have enough
information in render surface impl.

@senorblanco, do you have suggestions here? Thanks!

[Stephen White, 2017/03/09 01:05:08]

That's to accommodate the filter fast-path, which can return a "scratch" texture
from Skia as its result, often containing extra (garbage) pixels beyond the
result size. The tex rect is used by cc to crop out the garbage.

Whatever changes you make, you'll need to ensure that the rect returned by Skia
can be passed back to cc for cropping. I'm not sure how that interacts with
masks, or how much testing there is of the filter + mask combination.

+}
+
+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(
+      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());
+
+    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