Merge outline paint phases into the foreground phase.

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 973 matching lines @@
 
                 context->clipPath(clipPath->path(rootRelativeBounds), clipPath->windRule());
             }
         }
     }
 
     LayerPaintingInfo localPaintingInfo(paintingInfo);
     FilterEffectRendererHelper filterPainter(filterRenderer() && paintsWithFilters());
 
     LayoutRect layerBounds;
-    ClipRect backgroundRect, foregroundRect, outlineRect;
+    ClipRect backgroundRect, foregroundRect;
     ClipRectsContext clipRectsContext(localPaintingInfo.rootLayer, PaintingClipRects, localPaintingInfo.subPixelAccumulation);
     clipper().calculateRects(clipRectsContext, localPaintingInfo.paintDirtyRect,
-        layerBounds, backgroundRect, foregroundRect, outlineRect,
+        layerBounds, backgroundRect, foregroundRect,
         &offsetFromRoot);
 
     bool isPaintingOverlayScrollbars = paintFlags == PaintOverlayScrollbars;
     bool shouldPaintContent = isSelfPaintingLayer() && !isPaintingOverlayScrollbars
         && intersectsDamageRect(layerBounds, backgroundRect.rect(), localPaintingInfo.rootLayer, &offsetFromRoot);
 
     bool haveTransparency = isTransparent();
 
     if (filterPainter.haveFilterEffect()) {
         ASSERT(this->filterInfo());
@@ skipping 33 matching lines @@
     if (localPaintingInfo.paintingRoot && !renderer()->isDescendantOf(localPaintingInfo.paintingRoot))
         paintingRootForRenderer = localPaintingInfo.paintingRoot;
 
     LayoutPoint layerLocation = toPoint(layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation);
 
     if (shouldPaintContent) {
         paintForeground(context, transparencyLayerContext, paintingInfo.paintDirtyRect, haveTransparency,
             localPaintingInfo, paintingRootForRenderer, layerLocation, foregroundRect);
     }
 
-    paintOutline(context, localPaintingInfo, paintingRootForRenderer, layerLocation, outlineRect);

[ojan, 2015/01/27 04:44:40]

Honestly, not really sure why we don't need this call anymore. But I tested that
before this patch we need it for outlines on positioned elements and after this
patch we don't.

     paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags);
 
     if (isPaintingOverlayScrollbars)
         paintOverflowControls(context, localPaintingInfo, layerLocation, backgroundRect);
 
     if (filterPainter.hasStartedFilterEffect()) {
         context = filterPainter.applyFilterEffect();
         restoreClip(transparencyLayerContext, localPaintingInfo.paintDirtyRect, backgroundRect);
     }
 
@@ skipping 66 matching lines @@
     if (shouldClip)
         clipToRect(localPaintingInfo, context, layerForegroundRect);
 
     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(PaintPhaseForeground,
             context, localPaintingInfo, paintingRootForRenderer,
             layerLocation, layerForegroundRect);
-        paintForegroundWithPhase(PaintPhaseChildOutlines,
-            context, localPaintingInfo, paintingRootForRenderer,
-            layerLocation, layerForegroundRect);
     }
 
     if (shouldClip)
         restoreClip(context, localPaintingInfo.paintDirtyRect, layerForegroundRect);
 }
 
 void RenderLayer::paintForegroundWithPhase(PaintPhase phase, GraphicsContext* context,
     const LayerPaintingInfo& localPaintingInfo, RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerForegroundRect)
 {
     PaintInfo paintInfo(context, pixelSnappedIntRect(layerForegroundRect.rect()), phase, paintingRootForRenderer, localPaintingInfo.rootLayer->renderer());
     renderer()->paint(paintInfo, layerLocation);
 }
 
-void RenderLayer::paintOutline(GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
-    RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerOutlineRect)
-{
-    if (layerOutlineRect.isEmpty())
-        return;
-
-    PaintInfo paintInfo(context, pixelSnappedIntRect(layerOutlineRect.rect()), PaintPhaseSelfOutline, paintingRootForRenderer, localPaintingInfo.rootLayer->renderer());
-    clipToRect(localPaintingInfo, context, layerOutlineRect, DoNotIncludeSelfForBorderRadius);
-    renderer()->paint(paintInfo, layerLocation);
-    restoreClip(context, localPaintingInfo.paintDirtyRect, layerOutlineRect);
-}
-
 void RenderLayer::paintMask(GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo,
     RenderObject* paintingRootForRenderer, LayoutPoint& layerLocation, ClipRect& layerBackgroundRect)
 {
     if (localPaintingInfo.clipToDirtyRect)
         clipToRect(localPaintingInfo, context, layerBackgroundRect, 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(layerBackgroundRect.rect()), PaintPhaseMask, paintingRootForRenderer, localPaintingInfo.rootLayer->renderer());
     renderer()->paint(paintInfo, layerLocation);
@@ skipping 233 matching lines @@
     // Now check our overflow objects.
     hitLayer = hitTestChildren(NormalFlowChildren, rootLayer, request, result, hitTestRect, hitTestLocation,
                            localTransformState.get(), zOffsetForDescendantsPtr, zOffset, unflattenedTransformState.get(), depthSortDescendants);
     if (hitLayer) {
         if (!depthSortDescendants)
             return hitLayer;
         candidateLayer = hitLayer;
     }
 
     LayoutRect layerBounds;
-    ClipRect backgroundRect, foregroundRect, outlineRect;
+    ClipRect backgroundRect, foregroundRect;
     ClipRectsContext clipRectsContext(rootLayer, RootRelativeClipRects);
-    clipper().calculateRects(clipRectsContext, hitTestRect, layerBounds, backgroundRect, foregroundRect, outlineRect);
+    clipper().calculateRects(clipRectsContext, hitTestRect, layerBounds, backgroundRect, foregroundRect);
 
     // Next we want to see if the mouse pos is inside the child RenderObjects of the layer.
     if (isSelfPaintingLayer() && foregroundRect.intersects(hitTestLocation)) {
         // Hit test with a temporary HitTestResult, because we only want to commit to 'result' if we know we're frontmost.
         HitTestResult tempResult(result.hitTestLocation());
         if (hitTestContents(request, tempResult, layerBounds, hitTestLocation, HitTestDescendants)
             && isHitCandidate(this, false, zOffsetForContentsPtr, unflattenedTransformState.get())) {
             if (result.isRectBasedTest())
                 result.append(tempResult);
             else
@@ skipping 415 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif