Fix masks when scaling is in the tree

cc/render_surface_impl.cc

Index: cc/render_surface_impl.cc
diff --git a/cc/render_surface_impl.cc b/cc/render_surface_impl.cc
index bc3d7303ba917f79bf2d4abed882ec33d6c69e9f..8023da68239d2e1dc864095b994075866f338213 100644
--- a/cc/render_surface_impl.cc
+++ b/cc/render_surface_impl.cc
@@ -224,8 +224,14 @@ void RenderSurfaceImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQ
 
     gfx::RectF maskUVRect(0.0f, 0.0f, 1.0f, 1.0f);
     if (maskLayer) {
-        float scaleX = contentRect().width() / maskLayer->contentsScaleX() / maskLayer->bounds().width();
-        float scaleY = contentRect().height() / maskLayer->contentsScaleY() / maskLayer->bounds().height();
+        // Because the RenderSurface is sized base on the screen footprint,
+        // there can be a scale between the RenderSurface and the owning layer,
+        // as well as the mask. While the mask doesn't have a drawTransform, the
+        // owning layer has it (and should be pure scaling), so use that to
+        // scale the mask to the right size.
+        gfx::Vector2dF maskDrawScale = MathUtil::computeTransform2dScaleComponents(m_owningLayer->drawTransform(), 1.f);

[enne (OOO), 2013/01/15 04:12:43]

This will work given the current implementation of LTHCommon, but I had once
hoped that we could separate the scale of the owning layer from the scale of the
surface (in case you had some image with a bizarre scale that created a surface,
and then everything inside would get scaled to it).  It almost seems like the
mask layer's content's scale should just take this surface scale into account
and then this owning layer detail could be entirely hidden in
LayerTreeHostCommon.

[danakj, 2013/01/15 16:31:11]

I'm not sure I agree. My POV is that the mask is assumed to share the same
contents scale as the owning layer, so I think the mask needs to be drawn with
the same scale as the owning layer is. The "surface's scale" is in theory
independent of the owning layer's draw transform, but the mask layer should
continue to draw at the same scale as the owning layer to have its pixel
positions aligned.

[danakj, 2013/01/15 17:11:53]

Ok I take this back. I had developed an impression that the mask only applies to
its layer. But enne@ pointed me to https://www.webkit.org/blog/181/css-masks/
where it states:

"The mask will therefore overlay the child and all of its descendants"

So I guess we want to scale it to fill the entire render surface.

Which makes me then wonder why this wasn't working for this case. Is it because
the mask layer was being added to the root layer, so the contentRect of the
surface didn't match the size of the subtree? or because aura is drawing a mask
assuming it matches the size of the owning layer and not its subtree?

+        float scaleX = contentRect().width() / maskLayer->contentsScaleX() / maskLayer->bounds().width() / maskDrawScale.x();
+        float scaleY = contentRect().height() / maskLayer->contentsScaleY() / maskLayer->bounds().height() / maskDrawScale.y();
 
         maskUVRect = gfx::RectF(static_cast<float>(contentRect().x()) / contentRect().width() * scaleX,
                                 static_cast<float>(contentRect().y()) / contentRect().height() * scaleY,