Revert: 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 358 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::RectF mask_uv_rect;
+  gfx::Vector2dF mask_uv_scale;
   gfx::Vector2dF surface_contents_scale =
       OwningEffectNode()->surface_contents_scale;
-  PictureLayerImpl* mask_layer = static_cast<PictureLayerImpl*>(MaskLayer());
+  LayerImpl* mask_layer = 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());
-    // 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());
+    mask_uv_scale = gfx::Vector2dF(1.0f / unclipped_mask_target_size.width(),
+                                   1.0f / unclipped_mask_target_size.height());
   }
 
-  gfx::RectF tex_coord_rect(gfx::Rect(content_rect().size()));
   RenderPassDrawQuad* quad =
       render_pass->CreateAndAppendDrawQuad<RenderPassDrawQuad>();
   quad->SetNew(shared_quad_state, content_rect(), visible_layer_rect,
-               GetRenderPassId(), mask_resource_id, mask_uv_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(),
-               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::ScaleToEnclosedRect(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::ScaleToEnclosedRect(
-      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::ScaleToEnclosedRect(
-      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;
-    }
-  }
+               gfx::RectF());
 }
 
 }  // namespace cc