[NOT FOR COMMIT] Fully replace SkCanvas uses.

third_party/WebKit/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 "core/paint/SVGShapePainter.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/FloatClipRecorder.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/TransformRecorder.h"
 #include "platform/graphics/GraphicsContextStateSaver.h"
 #include "platform/graphics/paint/SkPictureBuilder.h"
 #include "third_party/skia/include/core/SkPaint.h"
-#include "third_party/skia/include/core/SkPicture.h"
+#include "skia/ext/cdl_picture.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 static bool setupNonScalingStrokeContext(
     AffineTransform& strokeTransform,
     GraphicsContextStateSaver& stateSaver) {
   if (!strokeTransform.isInvertible())
     return false;
 
@@ skipping 35 matching lines @@
           paintContext.paintInfo().context, m_layoutSVGShape,
           paintContext.paintInfo().phase, boundingBox);
       const SVGComputedStyle& svgStyle = m_layoutSVGShape.style()->svgStyle();
 
       bool shouldAntiAlias = svgStyle.shapeRendering() != SR_CRISPEDGES &&
                              svgStyle.shapeRendering() != SR_OPTIMIZESPEED;
 
       for (int i = 0; i < 3; i++) {
         switch (svgStyle.paintOrderType(i)) {
           case PT_FILL: {
-            SkPaint fillPaint;
+            CdlPaint fillPaint;
             if (!SVGPaintContext::paintForLayoutObject(
                     paintContext.paintInfo(), m_layoutSVGShape.styleRef(),
                     m_layoutSVGShape, ApplyToFillMode, fillPaint))
               break;
             fillPaint.setAntiAlias(shouldAntiAlias);
             fillShape(paintContext.paintInfo().context, fillPaint,
                       fillRuleFromStyle(paintContext.paintInfo(), svgStyle));
             break;
           }
           case PT_STROKE:
             if (svgStyle.hasVisibleStroke()) {
               GraphicsContextStateSaver stateSaver(
                   paintContext.paintInfo().context, false);
               AffineTransform nonScalingTransform;
               const AffineTransform* additionalPaintServerTransform = 0;
 
               if (m_layoutSVGShape.hasNonScalingStroke()) {
                 nonScalingTransform =
                     m_layoutSVGShape.nonScalingStrokeTransform();
                 if (!setupNonScalingStrokeContext(nonScalingTransform,
                                                   stateSaver))
                   return;
 
                 // Non-scaling stroke needs to reset the transform back to the
                 // host transform.
                 additionalPaintServerTransform = &nonScalingTransform;
               }
 
-              SkPaint strokePaint;
+              CdlPaint strokePaint;
               if (!SVGPaintContext::paintForLayoutObject(
                       paintContext.paintInfo(), m_layoutSVGShape.styleRef(),
                       m_layoutSVGShape, ApplyToStrokeMode, strokePaint,
                       additionalPaintServerTransform))
                 break;
               strokePaint.setAntiAlias(shouldAntiAlias);
 
               StrokeData strokeData;
               SVGLayoutSupport::applyStrokeStyleToStrokeData(
                   strokeData, m_layoutSVGShape.styleRef(), m_layoutSVGShape,
@@ skipping 32 matching lines @@
   ~PathWithTemporaryWindingRule() { m_path.setFillType(m_savedFillType); }
 
   const SkPath& getSkPath() const { return m_path; }
 
  private:
   SkPath& m_path;
   SkPath::FillType m_savedFillType;
 };
 
 void SVGShapePainter::fillShape(GraphicsContext& context,
-                                const SkPaint& paint,
+                                const CdlPaint& paint,
                                 SkPath::FillType fillType) {
   switch (m_layoutSVGShape.geometryCodePath()) {
     case RectGeometryFastPath:
       context.drawRect(m_layoutSVGShape.objectBoundingBox(), paint);
       break;
     case EllipseGeometryFastPath:
       context.drawOval(m_layoutSVGShape.objectBoundingBox(), paint);
       break;
     default: {
       PathWithTemporaryWindingRule pathWithWinding(m_layoutSVGShape.path(),
                                                    fillType);
       context.drawPath(pathWithWinding.getSkPath(), paint);
     }
   }
 }
 
 void SVGShapePainter::strokeShape(GraphicsContext& context,
-                                  const SkPaint& paint) {
+                                  const CdlPaint& paint) {
   if (!m_layoutSVGShape.style()->svgStyle().hasVisibleStroke())
     return;
 
   switch (m_layoutSVGShape.geometryCodePath()) {
     case RectGeometryFastPath:
       context.drawRect(m_layoutSVGShape.objectBoundingBox(), paint);
       break;
     case EllipseGeometryFastPath:
       context.drawOval(m_layoutSVGShape.objectBoundingBox(), paint);
       break;
@@ skipping 56 matching lines @@
       marker.markerTransformation(position.origin, position.angle,
                                   strokeWidth));
   Optional<FloatClipRecorder> clipRecorder;
   if (SVGLayoutSupport::isOverflowHidden(&marker))
     clipRecorder.emplace(paintInfo.context, marker, paintInfo.phase,
                          marker.viewport());
   SVGContainerPainter(marker).paint(paintInfo);
 }
 
 }  // namespace blink