Merge 92529 - Introduced fast path for border rendering when all visible sides are solid, same rg...

Source/WebCore/rendering/RenderBoxModelObject.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 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google Inc. 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 1280 matching lines @@
             // Since we clipped, no need to draw with a mitre.
             mitreAdjacentSide1 = false;
             mitreAdjacentSide2 = false;
         }
         
         drawLineForBoxSide(graphicsContext, sideRect.x(), sideRect.y(), sideRect.maxX(), sideRect.maxY(), side, colorToPaint, edgeToRender.style,
                 mitreAdjacentSide1 ? adjacentEdge1.width : 0, mitreAdjacentSide2 ? adjacentEdge2.width : 0, antialias);
     }
 }
 
+static LayoutRect calculateSideRect(const RoundedRect& outerBorder, const BorderEdge edges[], int side)
+{
+    LayoutRect sideRect = outerBorder.rect();
+    int width = edges[side].width;
+
+    if (side == BSTop)
+        sideRect.setHeight(width);
+    else if (side == BSBottom)
+        sideRect.shiftYEdgeTo(sideRect.maxY() - width);
+    else if (side == BSLeft)
+        sideRect.setWidth(width);
+    else
+        sideRect.shiftXEdgeTo(sideRect.maxX() - width);
+
+    return sideRect;
+}
+
 void RenderBoxModelObject::paintBorderSides(GraphicsContext* graphicsContext, const RenderStyle* style, const RoundedRect& outerBorder, const RoundedRect& innerBorder,
                                             const BorderEdge edges[], BorderEdgeFlags edgeSet, BackgroundBleedAvoidance bleedAvoidance,
                                             bool includeLogicalLeftEdge, bool includeLogicalRightEdge, bool antialias, const Color* overrideColor)
 {
     bool renderRadii = outerBorder.isRounded();
 
     Path roundedPath;
     if (renderRadii)
         roundedPath.addRoundedRect(outerBorder);
     
     if (edges[BSTop].shouldRender() && includesEdge(edgeSet, BSTop)) {
-        LayoutRect sideRect = outerBorder.rect();
-        sideRect.setHeight(edges[BSTop].width);
+        LayoutRect sideRect = calculateSideRect(outerBorder, edges, BSTop);
 
         bool usePath = renderRadii && (borderStyleHasInnerDetail(edges[BSTop].style) || borderWillArcInnerEdge(innerBorder.radii().topLeft(), innerBorder.radii().topRight()));
         paintOneBorderSide(graphicsContext, style, outerBorder, innerBorder, sideRect, BSTop, BSLeft, BSRight, edges, usePath ? &roundedPath : 0, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias, overrideColor);
     }
 
     if (edges[BSBottom].shouldRender() && includesEdge(edgeSet, BSBottom)) {
-        LayoutRect sideRect = outerBorder.rect();
-        sideRect.shiftYEdgeTo(sideRect.maxY() - edges[BSBottom].width);
+        LayoutRect sideRect = calculateSideRect(outerBorder, edges, BSBottom);
 
         bool usePath = renderRadii && (borderStyleHasInnerDetail(edges[BSBottom].style) || borderWillArcInnerEdge(innerBorder.radii().bottomLeft(), innerBorder.radii().bottomRight()));
         paintOneBorderSide(graphicsContext, style, outerBorder, innerBorder, sideRect, BSBottom, BSLeft, BSRight, edges, usePath ? &roundedPath : 0, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias, overrideColor);
     }
 
     if (edges[BSLeft].shouldRender() && includesEdge(edgeSet, BSLeft)) {
-        LayoutRect sideRect = outerBorder.rect();
-        sideRect.setWidth(edges[BSLeft].width);
+        LayoutRect sideRect = calculateSideRect(outerBorder, edges, BSLeft);
 
         bool usePath = renderRadii && (borderStyleHasInnerDetail(edges[BSLeft].style) || borderWillArcInnerEdge(innerBorder.radii().bottomLeft(), innerBorder.radii().topLeft()));
         paintOneBorderSide(graphicsContext, style, outerBorder, innerBorder, sideRect, BSLeft, BSTop, BSBottom, edges, usePath ? &roundedPath : 0, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias, overrideColor);
     }
 
     if (edges[BSRight].shouldRender() && includesEdge(edgeSet, BSRight)) {
-        LayoutRect sideRect = outerBorder.rect();
-        sideRect.shiftXEdgeTo(sideRect.maxX() - edges[BSRight].width);
+        LayoutRect sideRect = calculateSideRect(outerBorder, edges, BSRight);
 
         bool usePath = renderRadii && (borderStyleHasInnerDetail(edges[BSRight].style) || borderWillArcInnerEdge(innerBorder.radii().bottomRight(), innerBorder.radii().topRight()));
         paintOneBorderSide(graphicsContext, style, outerBorder, innerBorder, sideRect, BSRight, BSTop, BSBottom, edges, usePath ? &roundedPath : 0, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias, overrideColor);
     }
 }
 
 void RenderBoxModelObject::paintTranslucentBorderSides(GraphicsContext* graphicsContext, const RenderStyle* style, const RoundedRect& outerBorder, const RoundedRect& innerBorder,
                                                        const BorderEdge edges[], BackgroundBleedAvoidance bleedAvoidance, bool includeLogicalLeftEdge, bool includeLogicalRightEdge, bool antialias)
 {
     BorderEdgeFlags edgesToDraw = AllBorderEdges;
@@ skipping 98 matching lines @@
     bool haveAlphaColor = false;
     bool haveAllSolidEdges = true;
     bool allEdgesVisible = true;
     bool allEdgesShareColor = true;
     int firstVisibleEdge = -1;
 
     for (int i = BSTop; i <= BSLeft; ++i) {
         const BorderEdge& currEdge = edges[i];
         if (currEdge.presentButInvisible()) {
             allEdgesVisible = false;
+            allEdgesShareColor = false;
             continue;
         }
         
         if (!currEdge.width) {
             allEdgesVisible = false;
             continue;
         }
 
         if (firstVisibleEdge == -1)
             firstVisibleEdge = i;
         else if (currEdge.color != edges[firstVisibleEdge].color)
             allEdgesShareColor = false;
 
         if (currEdge.color.hasAlpha())
             haveAlphaColor = true;
         
         if (currEdge.style != SOLID)
             haveAllSolidEdges = false;
     }
 
     // If one of the corners falls outside the clip region, pretend it has no
     // radius to improve performance.
     if (haveAllSolidEdges)
         unroundClippedCorners(outerBorder, info.rect);
 
     // isRenderable() check avoids issue described in https://bugs.webkit.org/show_bug.cgi?id=38787
-    if (haveAllSolidEdges && allEdgesVisible && allEdgesShareColor && innerBorder.isRenderable()) {
+    if (haveAllSolidEdges && allEdgesShareColor && innerBorder.isRenderable()) {
         // Fast path for drawing all solid edges.
-        if (outerBorder.isRounded() || haveAlphaColor) {
+        if (allEdgesVisible && (outerBorder.isRounded() || haveAlphaColor)) {
             Path path;
             
             if (outerBorder.isRounded() && bleedAvoidance != BackgroundBleedUseTransparencyLayer)
                 path.addRoundedRect(outerBorder);
             else
                 path.addRect(outerBorder.rect());
 
             if (innerBorder.isRounded())
                 path.addRoundedRect(innerBorder);
             else
                 path.addRect(innerBorder.rect());
             
             graphicsContext->setFillRule(RULE_EVENODD);
             graphicsContext->setFillColor(edges[firstVisibleEdge].color, style->colorSpace());
             graphicsContext->fillPath(path);
-        } else
-            paintBorderSides(graphicsContext, style, outerBorder, innerBorder, edges, AllBorderEdges, bleedAvoidance, includeLogicalLeftEdge, includeLogicalRightEdge, antialias);
-    
-        return;
+            return;
+        } 
+        // Avoid creating transparent layers
+        if (!allEdgesVisible && !outerBorder.isRounded() && haveAlphaColor) {
+            Path path;
+
+            for (int i = BSTop; i <= BSLeft; ++i) {
+                const BorderEdge& currEdge = edges[i];
+                if (currEdge.shouldRender()) {
+                    LayoutRect sideRect = calculateSideRect(outerBorder, edges, i);
+                    path.addRect(sideRect);
+                }
+            }
+
+            graphicsContext->setFillRule(RULE_NONZERO);
+            graphicsContext->setFillColor(edges[firstVisibleEdge].color, style->colorSpace());
+            graphicsContext->fillPath(path);
+            return;
+        }
     }
 
     bool clipToOuterBorder = outerBorder.isRounded();
     GraphicsContextStateSaver stateSaver(*graphicsContext, clipToOuterBorder);
     if (clipToOuterBorder) {
         // Clip to the inner and outer radii rects.
         if (bleedAvoidance != BackgroundBleedUseTransparencyLayer)
             graphicsContext->addRoundedRectClip(outerBorder);
         graphicsContext->clipOutRoundedRect(innerBorder);
     }
@@ skipping 835 matching lines @@
         if (!continuationMap)
             continuationMap = new ContinuationMap;
         continuationMap->set(this, continuation);
     } else {
         if (continuationMap)
             continuationMap->remove(this);
     }
 }
 
 } // namespace WebCore