[NOT FOR COMMIT] Fully replace SkCanvas uses.

third_party/WebKit/Source/core/svg/graphics/SVGImage.cpp

 /*
  * Copyright (C) 2006 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2011. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 38 matching lines @@
 #include "platform/ScriptForbiddenScope.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/ImageObserver.h"
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "platform/graphics/paint/CullRect.h"
 #include "platform/graphics/paint/DrawingRecorder.h"
 #include "platform/graphics/paint/SkPictureBuilder.h"
 #include "platform/tracing/TraceEvent.h"
-#include "third_party/skia/include/core/SkPicture.h"
+#include "skia/ext/cdl_picture.h"
 #include "wtf/PassRefPtr.h"
 
 namespace blink {
 
 SVGImage::SVGImage(ImageObserver* observer)
     : Image(observer),
       m_paintController(PaintController::create()),
       m_hasPendingTimelineRewind(false) {}
 
 SVGImage::~SVGImage() {
@@ skipping 150 matching lines @@
       return FloatSize(solutionWidth, defaultObjectSize.height());
 
     float solutionHeight = resolveHeightForRatio(
         defaultObjectSize.width(), intrinsicSizingInfo.aspectRatio);
     return FloatSize(defaultObjectSize.width(), solutionHeight);
   }
 
   return defaultObjectSize;
 }
 
-void SVGImage::drawForContainer(SkCanvas* canvas,
-                                const SkPaint& paint,
+void SVGImage::drawForContainer(CdlCanvas* canvas,
+                                const CdlPaint& paint,
                                 const FloatSize containerSize,
                                 float zoom,
                                 const FloatRect& dstRect,
                                 const FloatRect& srcRect,
                                 const KURL& url) {
   if (!m_page)
     return;
 
   // Temporarily disable the image observer to prevent changeInRect() calls due
   // re-laying out the image.
@@ skipping 44 matching lines @@
 
   SkPictureBuilder patternPicture(spacedTile, nullptr, &context);
   {
     DrawingRecorder patternPictureRecorder(
         patternPicture.context(), patternPicture, DisplayItem::Type::kSVGImage,
         spacedTile);
     // When generating an expanded tile, make sure we don't draw into the
     // spacing area.
     if (tile != spacedTile)
       patternPicture.context().clip(tile);
-    SkPaint paint;
+    CdlPaint paint;
     drawForContainer(patternPicture.context().canvas(), paint, containerSize,
                      zoom, tile, srcRect, url);
   }
-  sk_sp<SkPicture> tilePicture = patternPicture.endRecording();
+  sk_sp<CdlPicture> tilePicture = patternPicture.endRecording();
 
   SkMatrix patternTransform;
   patternTransform.setTranslate(phase.x() + spacedTile.x(),
                                 phase.y() + spacedTile.y());
 
-  SkPaint paint;
-  paint.setShader(SkShader::MakePictureShader(
-      std::move(tilePicture), SkShader::kRepeat_TileMode,
-      SkShader::kRepeat_TileMode, &patternTransform, nullptr));
+  CdlPaint paint;
+  paint.setShader(CdlShader::MakePictureShader(
+      tilePicture, SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode,
+      &patternTransform, nullptr));
   paint.setBlendMode(compositeOp);
   paint.setColorFilter(sk_ref_sp(context.getColorFilter()));
   context.drawRect(dstRect, paint);
 }
 
 sk_sp<SkImage> SVGImage::imageForCurrentFrameForContainer(
     const KURL& url,
     const IntSize& containerSize) {
   if (!m_page)
     return nullptr;
 
   const FloatRect containerRect((FloatPoint()), FloatSize(containerSize));
 
-  SkPictureRecorder recorder;
-  SkCanvas* canvas = recorder.beginRecording(containerRect);
-  drawForContainer(canvas, SkPaint(), containerRect.size(), 1, containerRect,
+  CdlPictureRecorder recorder;
+  CdlCanvas* canvas = recorder.beginRecording(containerRect);
+  drawForContainer(canvas, CdlPaint(), containerRect.size(), 1, containerRect,
                    containerRect, url);
 
   return SkImage::MakeFromPicture(
-      recorder.finishRecordingAsPicture(),
+      ToSkPicture(recorder.finishRecordingAsPicture().get()),
       SkISize::Make(containerSize.width(), containerSize.height()), nullptr,
       nullptr);
 }
 
-static bool drawNeedsLayer(const SkPaint& paint) {
+static bool drawNeedsLayer(const CdlPaint& paint) {
   if (SkColorGetA(paint.getColor()) < 255)
     return true;
   return !paint.isSrcOver();
 }
 
-void SVGImage::draw(SkCanvas* canvas,
-                    const SkPaint& paint,
+void SVGImage::draw(CdlCanvas* canvas,
+                    const CdlPaint& paint,
                     const FloatRect& dstRect,
                     const FloatRect& srcRect,
                     RespectImageOrientationEnum shouldRespectImageOrientation,
                     ImageClampingMode clampMode) {
   if (!m_page)
     return;
 
   drawInternal(canvas, paint, dstRect, srcRect, shouldRespectImageOrientation,
                clampMode, KURL());
 }
 
-void SVGImage::drawInternal(SkCanvas* canvas,
-                            const SkPaint& paint,
+void SVGImage::drawInternal(CdlCanvas* canvas,
+                            const CdlPaint& paint,
                             const FloatRect& dstRect,
                             const FloatRect& srcRect,
                             RespectImageOrientationEnum,
                             ImageClampingMode,
                             const KURL& url) {
   DCHECK(m_page);
   FrameView* view = toLocalFrame(m_page->mainFrame())->view();
   view->resize(containerSize());
 
   // Always call processUrlFragment, even if the url is empty, because
@@ skipping 26 matching lines @@
     transform.scale(scale.width(), scale.height());
     TransformRecorder transformRecorder(imagePicture.context(), imagePicture,
                                         transform);
 
     view->updateAllLifecyclePhasesExceptPaint();
     view->paint(imagePicture.context(), CullRect(enclosingIntRect(srcRect)));
     ASSERT(!view->needsLayout());
   }
 
   {
-    SkAutoCanvasRestore ar(canvas, false);
+    CdlAutoCanvasRestore ar(canvas, false);
     if (drawNeedsLayer(paint)) {
       SkRect layerRect = dstRect;
       canvas->saveLayer(&layerRect, &paint);
     }
-    sk_sp<const SkPicture> recording = imagePicture.endRecording();
+    sk_sp<CdlPicture> recording = imagePicture.endRecording();
     canvas->drawPicture(recording.get());
   }
 
   // Start any (SMIL) animations if needed. This will restart or continue
   // animations if preceded by calls to resetAnimation or stopAnimation
   // respectively.
   startAnimation();
 }
 
 LayoutReplaced* SVGImage::embeddedReplacedContent() const {
@@ skipping 202 matching lines @@
   }
 
   return m_page ? SizeAvailable : SizeUnavailable;
 }
 
 String SVGImage::filenameExtension() const {
   return "svg";
 }
 
 }  // namespace blink