Inline RenderLayer::beginTransparencyLayers into RenderBox::paintLayerContents.

sky/engine/core/rendering/RenderBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 723 matching lines @@
 
     // Now do a paint with the root layer shifted to be us.
     LayerPaintingInfo transformedPaintingInfo(layer(), enclosingIntRect(transform.inverse().mapRect(paintingInfo.paintDirtyRect)),
         adjustedSubPixelAccumulation);
     paintLayerContents(context, transformedPaintingInfo);
 
     // Restore the clip.
     layer()->parent()->restoreClip(context, paintingInfo.paintDirtyRect, clipRect);
 }
 
+static LayoutRect transparencyClipBox(const RenderLayer*, const RenderLayer* rootLayer, const LayoutSize& subPixelAccumulation);
+
+static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const RenderLayer* layer, const RenderLayer* rootLayer,
+    const LayoutSize& subPixelAccumulation)
+{
+    // Note: we don't have to walk z-order lists since transparent elements always establish
+    // a stacking container. This means we can just walk the layer tree directly.
+    for (RenderLayer* curr = layer->firstChild(); curr; curr = curr->nextSibling())
+        clipRect.unite(transparencyClipBox(curr, rootLayer, subPixelAccumulation));
+}
+
+static LayoutRect transparencyClipBox(const RenderLayer* layer, const RenderLayer* rootLayer,
+    const LayoutSize& subPixelAccumulation)
+{
+    // FIXME: Although this function completely ignores CSS-imposed clipping, we did already intersect with the
+    // paintDirtyRect, and that should cut down on the amount we have to paint.  Still it
+    // would be better to respect clips.
+
+    if (rootLayer != layer && layer->transform()) {
+        // The best we can do here is to use enclosed bounding boxes to establish a "fuzzy" enough clip to encompass
+        // the transformed layer and all of its children.
+        const RenderLayer* rootLayerForTransform = rootLayer;
+        LayoutPoint delta;
+        layer->convertToLayerCoords(rootLayerForTransform, delta);
+
+        delta.move(subPixelAccumulation);
+        IntPoint pixelSnappedDelta = roundedIntPoint(delta);
+        TransformationMatrix transform;
+        transform.translate(pixelSnappedDelta.x(), pixelSnappedDelta.y());
+        transform = transform * *layer->transform();
+
+        // We don't use fragment boxes when collecting a transformed layer's bounding box, since it always
+        // paints unfragmented.y
+        LayoutRect clipRect = layer->physicalBoundingBox(layer);
+        expandClipRectForDescendantsAndReflection(clipRect, layer, layer, subPixelAccumulation);
+        layer->renderer()->style()->filterOutsets().expandRect(clipRect);
+        LayoutRect result = transform.mapRect(clipRect);
+        return result;
+    }
+
+    LayoutRect clipRect = layer->physicalBoundingBox(rootLayer);
+    expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, subPixelAccumulation);
+    layer->renderer()->style()->filterOutsets().expandRect(clipRect);
+    clipRect.move(subPixelAccumulation);
+    return clipRect;
+}
+
 void RenderBox::paintLayerContents(GraphicsContext* context, const LayerPaintingInfo& paintingInfo)
 {
     float deviceScaleFactor = blink::deviceScaleFactor(frame());
     context->setDeviceScaleFactor(deviceScaleFactor);
 
     LayoutPoint offsetFromRoot;
     layer()->convertToLayerCoords(paintingInfo.rootLayer, offsetFromRoot);
 
     LayerPaintingInfo localPaintingInfo(paintingInfo);
 
@@ skipping 27 matching lines @@
                 if (!rootRelativeBoundsComputed) {
                     rootRelativeBounds = layer()->physicalBoundingBoxIncludingReflectionAndStackingChildren(paintingInfo.rootLayer, offsetFromRoot);
                     rootRelativeBoundsComputed = true;
                 }
 
                 context->clipPath(clipPath->path(rootRelativeBounds), clipPath->windRule());
             }
         }
     }
 
-    if (layer()->isTransparent())
-        layer()->beginTransparencyLayers(context, localPaintingInfo.rootLayer, paintingInfo.paintDirtyRect, localPaintingInfo.subPixelAccumulation);
+    if (layer()->isTransparent()) {
+        context->save();
+        LayoutRect clipRect = intersection(paintingInfo.paintDirtyRect,
+            transparencyClipBox(layer(), localPaintingInfo.rootLayer, localPaintingInfo.subPixelAccumulation));
+        context->clip(clipRect);
+        context->beginTransparencyLayer(opacity());
+    }
 
     layer()->clipToRect(localPaintingInfo, context, contentRect);
 
     FilterEffectRendererHelper filterPainter(layer()->filterRenderer() && layer()->paintsWithFilters());
 
     if (filterPainter.haveFilterEffect()) {
         ASSERT(layer()->filterInfo());
 
         if (!rootRelativeBoundsComputed)
             rootRelativeBounds = layer()->physicalBoundingBoxIncludingReflectionAndStackingChildren(paintingInfo.rootLayer, offsetFromRoot);
@@ skipping 2159 matching lines @@
 
 RenderBox::BoxDecorationData::BoxDecorationData(const RenderStyle& style)
 {
     backgroundColor = style.colorIncludingFallback(CSSPropertyBackgroundColor);
     hasBackground = backgroundColor.alpha() || style.hasBackgroundImage();
     ASSERT(hasBackground == style.hasBackground());
     hasBorder = style.hasBorder();
 }
 
 } // namespace blink