Reverted the wrong one.

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 1017 matching lines @@
 
                 context->clipPath(clipPath->path(rootRelativeBounds), clipPath->windRule());
             }
         }
     }
 
     LayerPaintingInfo localPaintingInfo(paintingInfo);
     bool deferredFiltersEnabled = renderer()->document().settings()->deferredFiltersEnabled();
     FilterEffectRendererHelper filterPainter(filterRenderer() && paintsWithFilters());
 
-    // FIXME(sky): There's only one fragment. Get rid of the vector.
-    LayerFragments layerFragments;
-    LayerFragment fragment;
+    LayoutRect layerBounds;
+    ClipRect backgroundRect, foregroundRect, outlineRect;
     ClipRectsContext clipRectsContext(localPaintingInfo.rootLayer, PaintingClipRects, localPaintingInfo.subPixelAccumulation);
     clipper().calculateRects(clipRectsContext, localPaintingInfo.paintDirtyRect,
-        fragment.layerBounds, fragment.backgroundRect, fragment.foregroundRect, fragment.outlineRect,
+        layerBounds, backgroundRect, foregroundRect, outlineRect,
         &offsetFromRoot);
-    layerFragments.append(fragment);
 
     bool isPaintingOverlayScrollbars = paintFlags == PaintOverlayScrollbars;
-    bool shouldPaintContent = isSelfPaintingLayer() && !isPaintingOverlayScrollbars;
-    updatePaintingInfoForFragments(layerFragments, localPaintingInfo, shouldPaintContent, &offsetFromRoot);
+    bool shouldPaintContent = isSelfPaintingLayer() && !isPaintingOverlayScrollbars
+        && intersectsDamageRect(layerBounds, backgroundRect.rect(), localPaintingInfo.rootLayer, &offsetFromRoot);
 
     bool haveTransparency = isTransparent();
 
     if (filterPainter.haveFilterEffect()) {
         ASSERT(this->filterInfo());
 
         if (!rootRelativeBoundsComputed)
             rootRelativeBounds = physicalBoundingBoxIncludingReflectionAndStackingChildren(paintingInfo.rootLayer, offsetFromRoot);
 
         if (filterPainter.prepareFilterEffect(this, rootRelativeBounds, paintingInfo.paintDirtyRect)) {
 
             // Rewire the old context to a memory buffer, so that we can capture the contents of the layer.
             // NOTE: We saved the old context in the "transparencyLayerContext" local variable, to be able to start a transparency layer
             // on the original context and avoid duplicating "beginFilterEffect" after each transparency layer call. Also, note that
             // beginTransparencyLayers will only create a single lazy transparency layer, even though it is called twice in this method.
             // With deferred filters, we don't need a separate context, but we do need to do transparency and clipping before starting
             // filter processing.
             // FIXME: when the legacy path is removed, remove the transparencyLayerContext as well.
             if (deferredFiltersEnabled) {
                 if (haveTransparency) {
                     // If we have a filter and transparency, we have to eagerly start a transparency layer here, rather than risk a child layer lazily starts one after filter processing.
                     beginTransparencyLayers(context, localPaintingInfo.rootLayer, paintingInfo.paintDirtyRect, paintingInfo.subPixelAccumulation);
                 }
                 // We'll handle clipping to the dirty rect before filter rasterization.
                 // Filter processing will automatically expand the clip rect and the offscreen to accommodate any filter outsets.
                 // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
-                ClipRect backgroundRect = fragment.backgroundRect;
                 clipToRect(localPaintingInfo, context, backgroundRect);
                 // Subsequent code should not clip to the dirty rect, since we've already
                 // done it above, and doing it later will defeat the outsets.
                 localPaintingInfo.clipToDirtyRect = false;
             }
             context = filterPainter.beginFilterEffect(context);
 
             // Check that we didn't fail to allocate the graphics context for the offscreen buffer.
             if (filterPainter.hasStartedFilterEffect() && !deferredFiltersEnabled) {
                 localPaintingInfo.paintDirtyRect = filterPainter.paintInvalidationRect();
@@ skipping 11 matching lines @@
     }
 
     // If this layer's renderer is a child of the paintingRoot, we render unconditionally, which
     // is done by passing a nil paintingRoot down to our renderer (as if no paintingRoot was ever set).
     // Else, our renderer tree may or may not contain the painting root, so we pass that root along
     // so it will be tested against as we descend through the renderers.
     RenderObject* paintingRootForRenderer = 0;
     if (localPaintingInfo.paintingRoot && !renderer()->isDescendantOf(localPaintingInfo.paintingRoot))
         paintingRootForRenderer = localPaintingInfo.paintingRoot;
 
+    LayoutPoint layerLocation = toPoint(layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation);
+
     if (shouldPaintContent) {
-        paintBackgroundForFragments(layerFragments, context, transparencyLayerContext, paintingInfo.paintDirtyRect, haveTransparency,
-            localPaintingInfo, paintingRootForRenderer);
+        paintBackground(context, transparencyLayerContext, paintingInfo.paintDirtyRect, haveTransparency,
+            localPaintingInfo, paintingRootForRenderer, layerLocation, backgroundRect);
     }
 
     paintChildren(NegativeZOrderChildren, context, paintingInfo, paintFlags);
 
     if (shouldPaintContent) {
-        paintForegroundForFragments(layerFragments, context, transparencyLayerContext, paintingInfo.paintDirtyRect, haveTransparency,
-            localPaintingInfo, paintingRootForRenderer);
+        paintForeground(context, transparencyLayerContext, paintingInfo.paintDirtyRect, haveTransparency,
+            localPaintingInfo, paintingRootForRenderer, layerLocation, foregroundRect);
     }
 
-    paintOutlineForFragments(layerFragments, context, localPaintingInfo, paintingRootForRenderer);
+    paintOutline(context, localPaintingInfo, paintingRootForRenderer, layerLocation, outlineRect);
     paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags);
 
     if (isPaintingOverlayScrollbars)
-        paintOverflowControlsForFragments(layerFragments, context, localPaintingInfo);
+        paintOverflowControls(context, localPaintingInfo, layerLocation, backgroundRect);
 
     if (filterPainter.hasStartedFilterEffect()) {
         // Apply the correct clipping (ie. overflow: hidden).
         // FIXME: It is incorrect to just clip to the damageRect here once multiple fragments are involved.
-        ClipRect backgroundRect = fragment.backgroundRect;
         if (!deferredFiltersEnabled)
             clipToRect(localPaintingInfo, transparencyLayerContext, backgroundRect);
 
         context = filterPainter.applyFilterEffect();
         restoreClip(transparencyLayerContext, localPaintingInfo.paintDirtyRect, backgroundRect);
     }
 
     // Make sure that we now use the original transparency context.
     ASSERT(transparencyLayerContext == context);
 
     if (shouldPaintContent && renderer()->hasMask())
-        paintMaskForFragments(layerFragments, context, localPaintingInfo, paintingRootForRenderer);
+        paintMask(context, localPaintingInfo, paintingRootForRenderer, layerLocation, backgroundRect);
 
     // End our transparency layer
     if (haveTransparency && m_usedTransparency) {
         context->endLayer();
         context->restore();
         m_usedTransparency = false;
     }
 }
 
 void RenderLayer::paintLayerByApplyingTransform(GraphicsContext* context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutPoint& translationOffset)
@@ skipping 29 matching lines @@
 #if ENABLE(ASSERT)
     LayerListMutationDetector mutationChecker(m_stackingNode.get());
 #endif
 
     RenderLayerStackingNodeIterator iterator(*m_stackingNode, childrenToVisit);
     while (RenderLayerStackingNode* child = iterator.next()) {
         child->layer()->paintLayer(context, paintingInfo, paintFlags);
     }
 }
 
-void RenderLayer::updatePaintingInfoForFragments(LayerFragments& fragments, const LayerPaintingInfo& localPaintingInfo,
-    bool shouldPaintContent, const LayoutPoint* offsetFromRoot)
+void RenderLayer::paintBackground(GraphicsContext* context, GraphicsContext* transparencyLayerContext,
+    const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo& localPaintingInfo,
+    RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerBackgroundRect)
 {
-    ASSERT(offsetFromRoot);
-    for (size_t i = 0; i < fragments.size(); ++i) {
-        LayerFragment& fragment = fragments.at(i);
-        LayoutPoint newOffsetFromRoot = *offsetFromRoot;
-        fragment.shouldPaintContent = shouldPaintContent && intersectsDamageRect(fragment.layerBounds, fragment.backgroundRect.rect(), localPaintingInfo.rootLayer, &newOffsetFromRoot);
+    // Begin transparency layers lazily now that we know we have to paint something.
+    if (haveTransparency)
+        beginTransparencyLayers(transparencyLayerContext, localPaintingInfo.rootLayer, transparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation);
+
+    if (localPaintingInfo.clipToDirtyRect) {
+        // Paint our background first, before painting any child layers.
+        // Establish the clip used to paint our background.
+        clipToRect(localPaintingInfo, context, layerBackgroundRect, DoNotIncludeSelfForBorderRadius); // Background painting will handle clipping to self.
     }
+
+    // Paint the background.
+    // FIXME: Eventually we will collect the region from the fragment itself instead of just from the paint info.
+    PaintInfo paintInfo(context, pixelSnappedIntRect(layerBackgroundRect.rect()), PaintPhaseBlockBackground, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
+    renderer()->paint(paintInfo, layerLocation);
+
+    if (localPaintingInfo.clipToDirtyRect)
+        restoreClip(context, localPaintingInfo.paintDirtyRect, layerBackgroundRect);
 }
 
-void RenderLayer::paintBackgroundForFragments(const LayerFragments& layerFragments, GraphicsContext* context, GraphicsContext* transparencyLayerContext,
+void RenderLayer::paintForeground(GraphicsContext* context, GraphicsContext* transparencyLayerContext,
     const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo& localPaintingInfo,
-    RenderObject* paintingRootForRenderer)
+    RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerForegroundRect)
 {
-    for (size_t i = 0; i < layerFragments.size(); ++i) {
-        const LayerFragment& fragment = layerFragments.at(i);
-        if (!fragment.shouldPaintContent)
-            continue;
+    bool foregroundRectIsEmpty = layerForegroundRect.isEmpty();
 
-        // Begin transparency layers lazily now that we know we have to paint something.
-        if (haveTransparency)
-            beginTransparencyLayers(transparencyLayerContext, localPaintingInfo.rootLayer, transparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation);
+    // Begin transparency if we have something to paint.
+    if (haveTransparency && !foregroundRectIsEmpty)
+        beginTransparencyLayers(transparencyLayerContext, localPaintingInfo.rootLayer, transparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation);
 
-        if (localPaintingInfo.clipToDirtyRect) {
-            // Paint our background first, before painting any child layers.
-            // Establish the clip used to paint our background.
-            clipToRect(localPaintingInfo, context, fragment.backgroundRect, DoNotIncludeSelfForBorderRadius); // Background painting will handle clipping to self.
-        }
+    // Optimize clipping for the single fragment case.
+    bool shouldClip = localPaintingInfo.clipToDirtyRect && !foregroundRectIsEmpty;
+    if (shouldClip)
+        clipToRect(localPaintingInfo, context, layerForegroundRect);
 
-        // Paint the background.
-        // FIXME: Eventually we will collect the region from the fragment itself instead of just from the paint info.
-        PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.backgroundRect.rect()), PaintPhaseBlockBackground, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
-        renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation));
+    if (!foregroundRectIsEmpty) {
+        // We have to loop through every fragment multiple times, since we have to issue paint invalidations in each specific phase in order for
+        // interleaving of the fragments to work properly.
+        // FIXME(sky): Do we still need this for anything now that we don't have fragments?
+        paintForegroundWithPhase(PaintPhaseChildBlockBackgrounds,
+            context, localPaintingInfo, paintingRootForRenderer,
+            layerLocation, layerForegroundRect);
+        paintForegroundWithPhase(PaintPhaseForeground,
+            context, localPaintingInfo, paintingRootForRenderer,
+            layerLocation, layerForegroundRect);
+        paintForegroundWithPhase(PaintPhaseChildOutlines,
+            context, localPaintingInfo, paintingRootForRenderer,
+            layerLocation, layerForegroundRect);
+    }
 
-        if (localPaintingInfo.clipToDirtyRect)
-            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect);
-    }
+    if (shouldClip)
+        restoreClip(context, localPaintingInfo.paintDirtyRect, layerForegroundRect);
 }
 
-void RenderLayer::paintForegroundForFragments(const LayerFragments& layerFragments, GraphicsContext* context, GraphicsContext* transparencyLayerContext,
-    const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo& localPaintingInfo,
-    RenderObject* paintingRootForRenderer)
+void RenderLayer::paintForegroundWithPhase(PaintPhase phase, GraphicsContext* context,
+    const LayerPaintingInfo& localPaintingInfo, RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerForegroundRect)
 {
-    // Begin transparency if we have something to paint.
-    if (haveTransparency) {
-        for (size_t i = 0; i < layerFragments.size(); ++i) {
-            const LayerFragment& fragment = layerFragments.at(i);
-            if (fragment.shouldPaintContent && !fragment.foregroundRect.isEmpty()) {
-                beginTransparencyLayers(transparencyLayerContext, localPaintingInfo.rootLayer, transparencyPaintDirtyRect, localPaintingInfo.subPixelAccumulation);
-                break;
-            }
-        }
-    }
-
-    // Optimize clipping for the single fragment case.
-    bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size() == 1 && layerFragments[0].shouldPaintContent && !layerFragments[0].foregroundRect.isEmpty();
-    if (shouldClip)
-        clipToRect(localPaintingInfo, context, layerFragments[0].foregroundRect);
-
-    // We have to loop through every fragment multiple times, since we have to issue paint invalidations in each specific phase in order for
-    // interleaving of the fragments to work properly.
-    paintForegroundForFragmentsWithPhase(PaintPhaseChildBlockBackgrounds, layerFragments,
-        context, localPaintingInfo, paintingRootForRenderer);
-    paintForegroundForFragmentsWithPhase(PaintPhaseForeground, layerFragments, context, localPaintingInfo, paintingRootForRenderer);
-    paintForegroundForFragmentsWithPhase(PaintPhaseChildOutlines, layerFragments, context, localPaintingInfo, paintingRootForRenderer);
-
-    if (shouldClip)
-        restoreClip(context, localPaintingInfo.paintDirtyRect, layerFragments[0].foregroundRect);
+    PaintInfo paintInfo(context, pixelSnappedIntRect(layerForegroundRect.rect()), phase, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
+    renderer()->paint(paintInfo, layerLocation);
 }
 
-void RenderLayer::paintForegroundForFragmentsWithPhase(PaintPhase phase, const LayerFragments& layerFragments, GraphicsContext* context,
-    const LayerPaintingInfo& localPaintingInfo, RenderObject* paintingRootForRenderer)
+void RenderLayer::paintOutline(GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
+    RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerOutlineRect)
 {
-    bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size() > 1;
+    if (layerOutlineRect.isEmpty())
+        return;
 
-    for (size_t i = 0; i < layerFragments.size(); ++i) {
-        const LayerFragment& fragment = layerFragments.at(i);
-        if (!fragment.shouldPaintContent || fragment.foregroundRect.isEmpty())
-            continue;
-
-        if (shouldClip)
-            clipToRect(localPaintingInfo, context, fragment.foregroundRect);
-
-        PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.foregroundRect.rect()), phase, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
-        renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation));
-
-        if (shouldClip)
-            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.foregroundRect);
-    }
+    PaintInfo paintInfo(context, pixelSnappedIntRect(layerOutlineRect.rect()), PaintPhaseSelfOutline, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
+    clipToRect(localPaintingInfo, context, layerOutlineRect, DoNotIncludeSelfForBorderRadius);
+    renderer()->paint(paintInfo, layerLocation);
+    restoreClip(context, localPaintingInfo.paintDirtyRect, layerOutlineRect);
 }
 
-void RenderLayer::paintOutlineForFragments(const LayerFragments& layerFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
-    RenderObject* paintingRootForRenderer)
+void RenderLayer::paintMask(GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
+    RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerBackgroundRect)
 {
-    for (size_t i = 0; i < layerFragments.size(); ++i) {
-        const LayerFragment& fragment = layerFragments.at(i);
-        if (fragment.outlineRect.isEmpty())
-            continue;
+    if (localPaintingInfo.clipToDirtyRect)
+        clipToRect(localPaintingInfo, context, layerBackgroundRect, DoNotIncludeSelfForBorderRadius); // Mask painting will handle clipping to self.
 
-        PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.outlineRect.rect()), PaintPhaseSelfOutline, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
-        clipToRect(localPaintingInfo, context, fragment.outlineRect, DoNotIncludeSelfForBorderRadius);
-        renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation));
-        restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.outlineRect);
-    }
+    // Paint the mask.
+    // FIXME: Eventually we will collect the region from the fragment itself instead of just from the paint info.
+    PaintInfo paintInfo(context, pixelSnappedIntRect(layerBackgroundRect.rect()), PaintPhaseMask, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
+    renderer()->paint(paintInfo, layerLocation);
+
+    if (localPaintingInfo.clipToDirtyRect)
+        restoreClip(context, localPaintingInfo.paintDirtyRect, layerBackgroundRect);
 }
 
-void RenderLayer::paintMaskForFragments(const LayerFragments& layerFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
-    RenderObject* paintingRootForRenderer)
+void RenderLayer::paintOverflowControls(GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo, LayoutPoint& layerLocation, ClipRect& layerBackgroundRect)
 {
-    for (size_t i = 0; i < layerFragments.size(); ++i) {
-        const LayerFragment& fragment = layerFragments.at(i);
-        if (!fragment.shouldPaintContent)
-            continue;
-
-        if (localPaintingInfo.clipToDirtyRect)
-            clipToRect(localPaintingInfo, context, fragment.backgroundRect, DoNotIncludeSelfForBorderRadius); // Mask painting will handle clipping to self.
-
-        // Paint the mask.
-        // FIXME: Eventually we will collect the region from the fragment itself instead of just from the paint info.
-        PaintInfo paintInfo(context, pixelSnappedIntRect(fragment.backgroundRect.rect()), PaintPhaseMask, paintingRootForRenderer, 0, localPaintingInfo.rootLayer->renderer());
-        renderer()->paint(paintInfo, toPoint(fragment.layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation));
-
-        if (localPaintingInfo.clipToDirtyRect)
-            restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect);
-    }
-}
-
-void RenderLayer::paintOverflowControlsForFragments(const LayerFragments& layerFragments, GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo)
-{
-    for (size_t i = 0; i < layerFragments.size(); ++i) {
-        const LayerFragment& fragment = layerFragments.at(i);
-        clipToRect(localPaintingInfo, context, fragment.backgroundRect);
-        if (RenderLayerScrollableArea* scrollableArea = this->scrollableArea())
-            scrollableArea->paintOverflowControls(context, roundedIntPoint(toPoint(fragment.layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation)), pixelSnappedIntRect(fragment.backgroundRect.rect()), true);
-        restoreClip(context, localPaintingInfo.paintDirtyRect, fragment.backgroundRect);
-    }
+    clipToRect(localPaintingInfo, context, layerBackgroundRect);
+    if (RenderLayerScrollableArea* scrollableArea = this->scrollableArea())
+        scrollableArea->paintOverflowControls(context, roundedIntPoint(layerLocation), pixelSnappedIntRect(layerBackgroundRect.rect()), true);
+    restoreClip(context, localPaintingInfo.paintDirtyRect, layerBackgroundRect);
 }
 
 static inline LayoutRect frameVisibleRect(RenderObject* renderer)
 {
     FrameView* frameView = renderer->document().view();
     if (!frameView)
         return LayoutRect();
 
     return frameView->visibleContentRect();
 }
@@ skipping 768 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif