cc: Remove incorrect dcheck for masks.

cc/layers/render_surface_impl.cc

Index: cc/layers/render_surface_impl.cc
diff --git a/cc/layers/render_surface_impl.cc b/cc/layers/render_surface_impl.cc
index 741526a8db0904ac03824340c84eb6e0fe5b563b..303fca9519ab0484b06353854fc161769070bbfe 100644
--- a/cc/layers/render_surface_impl.cc
+++ b/cc/layers/render_surface_impl.cc
@@ -250,16 +250,33 @@ void RenderSurfaceImpl::AppendQuads(QuadSink* quad_sink,
     gfx::Vector2dF owning_layer_draw_scale =
         MathUtil::ComputeTransform2dScaleComponents(
             owning_layer_->draw_transform(), 1.f);
-    gfx::SizeF unclipped_surface_size = gfx::ScaleSize(
+    gfx::SizeF unclipped_mask_target_size = gfx::ScaleSize(
         owning_layer_->content_bounds(),
         owning_layer_draw_scale.x(),
         owning_layer_draw_scale.y());
-    // This assumes that the owning layer clips its subtree when a mask is
-    // present.
-    DCHECK(gfx::RectF(unclipped_surface_size).Contains(content_rect_));
-
-    float uv_scale_x = content_rect_.width() / unclipped_surface_size.width();
-    float uv_scale_y = content_rect_.height() / unclipped_surface_size.height();
+    gfx::SizeF clipped_mask_target_size = gfx::IntersectRects(

[enne (OOO), 2013/04/16 21:06:44]

I'm a little confused about this intersection.  Don't masks get stretched?

[danakj, 2013/04/16 21:21:01]

This is the old behaviour minus assumptions that the content_rect_ == owning
layer's bounds.

Masks do not get stretched. Previously we have the scale as content_rect.width /
unclipped_surface_size.width. What that was trying to do was say "if the owning
layer is 100x100 but the surface texture gets clipped to 20x20, then map
correctly from from the surface texture, where 0...1 represents 0-20, to the
mask texture where 0...1 represents 0-100. So we need to scale the coords down
to get the same pixels in the mask texture as if the surface texture was
unclipped.

Previously this code just used the content_rect_. But if you have a replica with
a mask, then the content_rect_ != the owning layer's clipped space in the target
surface. So instead of using the full content_rect_, just use the part for the
owning layer.

If another layer makes the surface larger on the left, but the surface texture
is clipping the right half of the owning layer, then this will map the tex
coords for the mask to match the texels of the owning layer, not the owning
layer + its children.

[shawnsingh, 2013/04/16 23:08:26]

I don't understand this - if the surface has a mask, it's masking to bounds, and
its origin will be its top-left.  no other layer can make the surface "larger on
the left" then.   What am I missing?

[danakj, 2013/04/16 23:13:55]

if the replica has a mask, the layer does not mask to bounds and the surface can
grow.

that said beautiful pixel tests have shown a bug in here for that scenario.

+        gfx::RectF(unclipped_mask_target_size), content_rect_).size();
+
+    gfx::Vector2dF unclipped_to_clipped_mask_target_size(
+        clipped_mask_target_size.width() /
+        unclipped_mask_target_size.width(),
+        clipped_mask_target_size.height() /
+        unclipped_mask_target_size.height());
+
+    gfx::Vector2dF owning_layer_to_mask_layer_bounds_ratio(

[enne (OOO), 2013/04/16 21:06:44]

This whole function needs a lot more comments about what's going on here.

[danakj, 2013/04/16 21:21:01]

ok, will add.

+        (static_cast<float>(mask_layer->content_bounds().width()) /
+         mask_layer->bounds().width()) /
+        (static_cast<float>(owning_layer_->content_bounds().width()) /
+         owning_layer_->bounds().width()),
+        (static_cast<float>(mask_layer->content_bounds().height()) /
+         mask_layer->bounds().height()) /
+        (static_cast<float>(owning_layer_->content_bounds().height()) /
+         owning_layer_->bounds().height()));
+
+    float uv_scale_x = unclipped_to_clipped_mask_target_size.x() *
+                       owning_layer_to_mask_layer_bounds_ratio.x();
+    float uv_scale_y = unclipped_to_clipped_mask_target_size.y() *
+                       owning_layer_to_mask_layer_bounds_ratio.y();
 
     mask_uv_rect = gfx::RectF(
         uv_scale_x * content_rect_.x() / content_rect_.width(),