Simplify and reduce calls to beginTransparencyLayers.

sky/engine/core/rendering/RenderLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 65 matching lines @@
 #include "sky/engine/wtf/StdLibExtras.h"
 #include "sky/engine/wtf/text/CString.h"
 
 namespace blink {
 
 RenderLayer::RenderLayer(RenderBox* renderer, LayerType type)
     : m_layerType(type)
     , m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_isRootLayer(renderer->isRenderView())
-    , m_usedTransparency(false)
     , m_3DTransformedDescendantStatusDirty(true)
     , m_has3DTransformedDescendant(false)
     , m_hasFilterInfo(false)
     , m_renderer(renderer)
     , m_parent(0)
     , m_previous(0)
     , m_next(0)
     , m_first(0)
     , m_last(0)
     , m_clipper(*renderer)
@@ skipping 307 matching lines @@
 bool RenderLayer::hasAncestorWithFilterOutsets() const
 {
     for (const RenderLayer* curr = this; curr; curr = curr->parent()) {
         RenderBox* renderer = curr->renderer();
         if (renderer->style()->hasFilterOutsets())
             return true;
     }
     return false;
 }
 
-RenderLayer* RenderLayer::transparentPaintingAncestor()
-{
-    for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
-        if (curr->isTransparent())
-            return curr;
-    }
-    return 0;
-}
-
 enum TransparencyClipBoxBehavior {
     PaintingTransparencyClipBox,
     HitTestingTransparencyClipBox
 };
 
-enum TransparencyClipBoxMode {
-    DescendantsOfTransparencyClipBox,
-    RootOfTransparencyClipBox
-};
-
-static LayoutRect transparencyClipBox(const RenderLayer*, const RenderLayer* rootLayer, TransparencyClipBoxBehavior, TransparencyClipBoxMode, const LayoutSize& subPixelAccumulation);
+static LayoutRect transparencyClipBox(const RenderLayer*, const RenderLayer* rootLayer, const LayoutSize& subPixelAccumulation);
 
 static void expandClipRectForDescendantsAndReflection(LayoutRect& clipRect, const RenderLayer* layer, const RenderLayer* rootLayer,
-    TransparencyClipBoxBehavior transparencyBehavior, const LayoutSize& subPixelAccumulation)
+    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, transparencyBehavior, DescendantsOfTransparencyClipBox, subPixelAccumulation));
+        clipRect.unite(transparencyClipBox(curr, rootLayer, subPixelAccumulation));
 }
 
-static LayoutRect transparencyClipBox(const RenderLayer* layer, const RenderLayer* rootLayer, TransparencyClipBoxBehavior transparencyBehavior,
-    TransparencyClipBoxMode transparencyMode, const LayoutSize& 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 && ((transparencyBehavior == PaintingTransparencyClipBox && layer->transform())
-        || (transparencyBehavior == HitTestingTransparencyClipBox && layer->hasTransform()))) {
+    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.
+        // paints unfragmented.y
         LayoutRect clipRect = layer->physicalBoundingBox(layer);
-        expandClipRectForDescendantsAndReflection(clipRect, layer, layer, transparencyBehavior, subPixelAccumulation);
+        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, transparencyBehavior, subPixelAccumulation);
+    expandClipRectForDescendantsAndReflection(clipRect, layer, rootLayer, subPixelAccumulation);
     layer->renderer()->style()->filterOutsets().expandRect(clipRect);
     clipRect.move(subPixelAccumulation);
     return clipRect;
 }
 
-LayoutRect RenderLayer::paintingExtent(const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation)
-{
-    return intersection(transparencyClipBox(this, rootLayer, PaintingTransparencyClipBox, RootOfTransparencyClipBox, subPixelAccumulation), paintDirtyRect);
-}
-
 void RenderLayer::beginTransparencyLayers(GraphicsContext* context, const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation)
 {
-    if (isTransparent() && m_usedTransparency)
-        return;
-
-    RenderLayer* ancestor = transparentPaintingAncestor();
-    if (ancestor)
-        ancestor->beginTransparencyLayers(context, rootLayer, paintDirtyRect, subPixelAccumulation);
-
-    if (isTransparent()) {
-        m_usedTransparency = true;
-        context->save();
-        LayoutRect clipRect = paintingExtent(rootLayer, paintDirtyRect, subPixelAccumulation);
-        context->clip(clipRect);
-
-        context->beginTransparencyLayer(renderer()->opacity());
-
-#ifdef REVEAL_TRANSPARENCY_LAYERS
-        context->setFillColor(Color(0.0f, 0.0f, 0.5f, 0.2f));
-        context->fillRect(clipRect);
-#endif
-    }
+    ASSERT(isTransparent());
+    context->save();
+    LayoutRect clipRect = intersection(paintDirtyRect,
+        transparencyClipBox(this, rootLayer, subPixelAccumulation));
+    context->clip(clipRect);
+    context->beginTransparencyLayer(renderer()->opacity());
 }
 
 void* RenderLayer::operator new(size_t sz)
 {
     return partitionAlloc(Partitions::getRenderingPartition(), sz);
 }
 
 void RenderLayer::operator delete(void* ptr)
 {
     partitionFree(ptr);
@@ skipping 503 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif