cc: Remove incorrect dcheck for masks.

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 <algorithm>
 
 #include "base/logging.h"
 #include "base/stringprintf.h"
@@ skipping 232 matching lines @@
     if (mask_layer &&
         (!mask_layer->DrawsContent() || mask_layer->bounds().IsEmpty()))
       mask_layer = NULL;
   }
 
   gfx::RectF mask_uv_rect(0.f, 0.f, 1.f, 1.f);
   if (mask_layer) {
     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_));
+    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();
 
-    float uv_scale_x = content_rect_.width() / unclipped_surface_size.width();
-    float uv_scale_y = content_rect_.height() / unclipped_surface_size.height();
+    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(),
         uv_scale_y * content_rect_.y() / content_rect_.height(),
         uv_scale_x,
         uv_scale_y);
   }
 
   ResourceProvider::ResourceId mask_resource_id =
       mask_layer ? mask_layer->ContentsResourceId() : 0;
   gfx::Rect contents_changed_since_last_frame =
       ContentsChanged() ? content_rect_ : gfx::Rect();
 
   scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                content_rect_,
                render_pass_id,
                for_replica,
                mask_resource_id,
                contents_changed_since_last_frame,
                mask_uv_rect,
                owning_layer_->filters(),
                owning_layer_->filter(),
                owning_layer_->background_filters());
   quad_sink->Append(quad.PassAs<DrawQuad>(), append_quads_data);
 }
 
 }  // namespace cc