Use SkPictureBuilder in SVGShapePainter, and generalize SkPictureBuilder.

Source/core/paint/SVGShapePainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/SVGShapePainter.h"
 
 #include "core/layout/svg/LayoutSVGPath.h"
 #include "core/layout/svg/LayoutSVGResourceMarker.h"
 #include "core/layout/svg/LayoutSVGShape.h"
 #include "core/layout/svg/SVGLayoutSupport.h"
 #include "core/layout/svg/SVGMarkerData.h"
 #include "core/layout/svg/SVGResources.h"
 #include "core/layout/svg/SVGResourcesCache.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/ObjectPainter.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/SVGContainerPainter.h"
 #include "core/paint/SVGPaintContext.h"
+#include "core/paint/ScopeRecorder.h"
 #include "core/paint/TransformRecorder.h"
-#include "platform/graphics/paint/DisplayItemListContextRecorder.h"
+#include "platform/graphics/paint/SkPictureBuilder.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 static bool setupNonScalingStrokeContext(AffineTransform& strokeTransform, GraphicsContextStateSaver& stateSaver)
 {
     if (!strokeTransform.isInvertible())
         return false;
@@ skipping 62 matching lines @@
                             strokePaint.setAntiAlias(shouldAntiAlias);
 
                             StrokeData strokeData;
                             SVGLayoutSupport::applyStrokeStyleToStrokeData(strokeData, m_layoutSVGShape.styleRef(), m_layoutSVGShape);
                             strokeData.setupPaint(&strokePaint);
 
                             strokeShape(paintContext.paintInfo().context, strokePaint);
                         }
                         break;
                     case PT_MARKERS:
-                        paintMarkers(paintContext.paintInfo());
+                        paintMarkers(paintContext.paintInfo(), boundingBox);
                         break;
                     default:
                         ASSERT_NOT_REACHED();
                         break;
                     }
                 }
             }
         }
     }
 
@@ skipping 57 matching lines @@
     default:
         ASSERT(m_layoutSVGShape.hasPath());
         Path* usePath = &m_layoutSVGShape.path();
         if (m_layoutSVGShape.hasNonScalingStroke())
             usePath = m_layoutSVGShape.nonScalingStrokePath(usePath, m_layoutSVGShape.nonScalingStrokeTransform());
         context->drawPath(usePath->skPath(), paint);
         strokeZeroLengthLineCaps(context, paint);
     }
 }
 
-void SVGShapePainter::paintMarkers(const PaintInfo& paintInfo)
+void SVGShapePainter::paintMarkers(const PaintInfo& paintInfo, const FloatRect& boundingBox)
 {
     const Vector<MarkerPosition>* markerPositions = m_layoutSVGShape.markerPositions();
     if (!markerPositions || markerPositions->isEmpty())
         return;
 
     SVGResources* resources = SVGResourcesCache::cachedResourcesForLayoutObject(&m_layoutSVGShape);
     if (!resources)
         return;
 
     LayoutSVGResourceMarker* markerStart = resources->markerStart();
     LayoutSVGResourceMarker* markerMid = resources->markerMid();
     LayoutSVGResourceMarker* markerEnd = resources->markerEnd();
     if (!markerStart && !markerMid && !markerEnd)
         return;
 
     float strokeWidth = m_layoutSVGShape.strokeWidth();
     unsigned size = markerPositions->size();
+    SkPictureBuilder pictureBuilder(boundingBox, nullptr, paintInfo.context);
+    PaintInfo markersPaintInfo(paintInfo);
+    markersPaintInfo.context = &pictureBuilder.context();
+
+    // It's expensive to track the transformed paint cull rect for each
+    // marker so just disable culling. The shape paint call will already be
+    // culled if it is outside the paint info cull rect.
+    markersPaintInfo.rect = LayoutRect::infiniteIntRect();
+
     for (unsigned i = 0; i < size; ++i) {
+        ScopeRecorder scopeRecorder(*markersPaintInfo.context, m_layoutSVGShape);
         if (LayoutSVGResourceMarker* marker = SVGMarkerData::markerForType((*markerPositions)[i].type, markerStart, markerMid, markerEnd))
-            paintMarker(paintInfo, *marker, (*markerPositions)[i], strokeWidth);
+            paintMarker(markersPaintInfo, *marker, (*markerPositions)[i], strokeWidth);
     }
+
+    pictureBuilder.endRecording()->playback(paintInfo.context->canvas());
 }
 
 void SVGShapePainter::paintMarker(const PaintInfo& paintInfo, LayoutSVGResourceMarker& marker, const MarkerPosition& position, float strokeWidth)
 {
     // An empty viewBox disables rendering.
     SVGMarkerElement* markerElement = toSVGMarkerElement(marker.element());
     ASSERT(markerElement);
     if (markerElement->hasAttribute(SVGNames::viewBoxAttr) && markerElement->viewBox()->currentValue()->isValid() && markerElement->viewBox()->currentValue()->value().isEmpty())
         return;
 
-    {
-        DisplayItemListContextRecorder contextRecorder(*paintInfo.context);
-        PaintInfo markerPaintInfo(paintInfo);
-        markerPaintInfo.context = &contextRecorder.context();
+    TransformRecorder transformRecorder(*paintInfo.context, marker, marker.markerTransformation(position.origin, position.angle, strokeWidth));
+    Optional<FloatClipRecorder> clipRecorder;
+    if (SVGLayoutSupport::isOverflowHidden(&marker))
+        clipRecorder.emplace(*paintInfo.context, marker, paintInfo.phase, marker.viewport());
 
-        // It's expensive to track the transformed paint cull rect for each
-        // marker so just disable culling. The shape paint call will already be
-        // culled if it is outside the paint info cull rect.
-        markerPaintInfo.rect = LayoutRect::infiniteIntRect();
-
-        TransformRecorder transformRecorder(*markerPaintInfo.context, marker, marker.markerTransformation(position.origin, position.angle, strokeWidth));
-        Optional<FloatClipRecorder> clipRecorder;
-        if (SVGLayoutSupport::isOverflowHidden(&marker))
-            clipRecorder.emplace(*markerPaintInfo.context, marker, markerPaintInfo.phase, marker.viewport());
-
-        SVGContainerPainter(marker).paint(markerPaintInfo);
-    }
+    SVGContainerPainter(marker).paint(paintInfo);
 }
 
 void SVGShapePainter::strokeZeroLengthLineCaps(GraphicsContext* context, const SkPaint& strokePaint)
 {
     const Vector<FloatPoint>* zeroLengthLineCaps = m_layoutSVGShape.zeroLengthLineCaps();
     if (!zeroLengthLineCaps || zeroLengthLineCaps->isEmpty())
         return;
 
     // We need a paint for filling.
     SkPaint fillPaint = strokePaint;
@@ skipping 14 matching lines @@
             position = nonScalingTransform.mapPoint(position);
         FloatRect subpathRect = LayoutSVGPath::zeroLengthSubpathRect(position, m_layoutSVGShape.strokeWidth());
         if (m_layoutSVGShape.style()->svgStyle().capStyle() == SquareCap)
             context->drawRect(subpathRect, fillPaint);
         else
             context->drawOval(subpathRect, fillPaint);
     }
 }
 
 } // namespace blink