Implement SVGImage::applyShader()

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 212 matching lines @@
       return FloatSize(solutionWidth, defaultObjectSize.height());
 
     float solutionHeight = resolveHeightForRatio(
         defaultObjectSize.width(), intrinsicSizingInfo.aspectRatio);
     return FloatSize(defaultObjectSize.width(), solutionHeight);
   }
 
   return defaultObjectSize;
 }
 
-void SVGImage::drawForContainer(PaintCanvas* canvas,
-                                const PaintFlags& flags,
-                                const FloatSize containerSize,
-                                float zoom,
-                                const FloatRect& dstRect,
-                                const FloatRect& srcRect,
-                                const KURL& url) {
+template <typename Func>
+void SVGImage::forContainer(const FloatSize& containerSize, Func&& func) {
   if (!m_page)
     return;
 
   // Temporarily disable the image observer to prevent changeInRect() calls due
   // re-laying out the image.
   ImageObserverDisabler imageObserverDisabler(this);
 
   IntSize roundedContainerSize = roundedIntSize(containerSize);
 
   if (SVGSVGElement* rootElement = svgRootElement(m_page.get())) {
     if (LayoutSVGRoot* layoutObject =
             toLayoutSVGRoot(rootElement->layoutObject()))
       layoutObject->setContainerSize(roundedContainerSize);
   }
 
+  func(FloatSize(roundedContainerSize.width() / containerSize.width(),
+                 roundedContainerSize.height() / containerSize.height()));
+}
+
+void SVGImage::drawForContainer(PaintCanvas* canvas,
+                                const PaintFlags& flags,
+                                const FloatSize& containerSize,
+                                float zoom,
+                                const FloatRect& dstRect,
+                                const FloatRect& srcRect,
+                                const KURL& url) {
   FloatRect scaledSrc = srcRect;
   scaledSrc.scale(1 / zoom);

[fs, 2017/03/15 21:08:58]

Maybe we could move this into the lambda scope as well? (To make it more obvious
there's no dependency outside of it.)

[f(malita), 2017/03/16 12:59:03]

Done.

 
-  // Compensate for the container size rounding by adjusting the source rect.
-  FloatSize adjustedSrcSize = scaledSrc.size();
-  adjustedSrcSize.scale(roundedContainerSize.width() / containerSize.width(),
-                        roundedContainerSize.height() / containerSize.height());
-  scaledSrc.setSize(adjustedSrcSize);
+  forContainer(containerSize, [&](const FloatSize& residualScale) {
+    // Compensate for the container size rounding by adjusting the source rect.
+    FloatSize adjustedSrcSize = scaledSrc.size();
+    adjustedSrcSize.scale(residualScale.width(), residualScale.height());
+    scaledSrc.setSize(adjustedSrcSize);
 
-  drawInternal(canvas, flags, dstRect, scaledSrc, DoNotRespectImageOrientation,
-               ClampImageToSourceRect, url);
+    drawInternal(canvas, flags, dstRect, scaledSrc,
+                 DoNotRespectImageOrientation, ClampImageToSourceRect, url);
+  });
 }
 
 sk_sp<SkImage> SVGImage::imageForCurrentFrame() {
   return imageForCurrentFrameForContainer(KURL(), size());
 }
 
 void SVGImage::drawPatternForContainer(GraphicsContext& context,
                                        const FloatSize containerSize,
                                        float zoom,
                                        const FloatRect& srcRect,
@@ skipping 72 matching lines @@
       SkISize::Make(containerSize.width(), containerSize.height()), nullptr,
       nullptr, SkImage::BitDepth::kU8, SkColorSpace::MakeSRGB());
 }
 
 static bool drawNeedsLayer(const PaintFlags& flags) {
   if (SkColorGetA(flags.getColor()) < 255)
     return true;
   return !flags.isSrcOver();
 }
 
+bool SVGImage::applyShaderInternal(PaintFlags& flags,
+                                   const SkMatrix& localMatrix,
+                                   const KURL& url) {
+  const FloatSize size(containerSize());
+  if (size.isEmpty())
+    return false;
+
+  const FloatRect bounds(FloatPoint(), size);
+  flags.setShader(SkShader::MakePictureShader(
+      paintRecordForCurrentFrame(bounds, bounds, url),
+      SkShader::kRepeat_TileMode, SkShader::kRepeat_TileMode, &localMatrix,
+      nullptr));
+
+  // Animation is normally refreshed in draw() impls, which we don't reach when
+  // painting via shaders.
+  startAnimation();
+
+  return true;
+}
+
+bool SVGImage::applyShader(PaintFlags& flags, const SkMatrix& localMatrix) {
+  return applyShaderInternal(flags, localMatrix, KURL());
+}
+
+bool SVGImage::applyShaderForContainer(const FloatSize& containerSize,
+                                       float zoom,
+                                       const KURL& url,
+                                       PaintFlags& flags,
+                                       const SkMatrix& localMatrix) {
+  bool result = false;
+  forContainer(containerSize, [&](const FloatSize& residualScale) {
+    // Compensate for the container size rounding.
+    auto adjustedLocalMatrix = localMatrix;
+    adjustedLocalMatrix.preScale(zoom * residualScale.width(),
+                                 zoom * residualScale.height());
+
+    result = applyShaderInternal(flags, adjustedLocalMatrix, url);
+  });
+
+  return result;
+}
+
 void SVGImage::draw(PaintCanvas* canvas,
                     const PaintFlags& flags,
                     const FloatRect& dstRect,
                     const FloatRect& srcRect,
                     RespectImageOrientationEnum shouldRespectImageOrientation,
                     ImageClampingMode clampMode) {
   if (!m_page)
     return;
 
   drawInternal(canvas, flags, dstRect, srcRect, shouldRespectImageOrientation,
                clampMode, KURL());
 }
 
-void SVGImage::drawInternal(PaintCanvas* canvas,
-                            const PaintFlags& flags,
-                            const FloatRect& dstRect,
-                            const FloatRect& srcRect,
-                            RespectImageOrientationEnum,
-                            ImageClampingMode,
-                            const KURL& url) {
+sk_sp<PaintRecord> SVGImage::paintRecordForCurrentFrame(
+    const FloatRect& srcRect,
+    const FloatRect& dstRect,
+    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
   // there may have been a previous url/fragment that needs to be reset.
   view->processUrlFragment(url);
 
   // If the image was reset, we need to rewind the timeline back to 0. This
   // needs to be done before painting, or else we wouldn't get the correct
@@ skipping 29 matching lines @@
     AffineTransform transform =
         AffineTransform::translation(destOffset.x(), destOffset.y());
     transform.scale(scale.width(), scale.height());
     TransformRecorder transformRecorder(builder.context(), builder, transform);
 
     view->updateAllLifecyclePhasesExceptPaint();
     view->paint(builder.context(), CullRect(enclosingIntRect(srcRect)));
     DCHECK(!view->needsLayout());
   }
 
+  return builder.endRecording();
+}
+
+void SVGImage::drawInternal(PaintCanvas* canvas,
+                            const PaintFlags& flags,
+                            const FloatRect& dstRect,
+                            const FloatRect& srcRect,
+                            RespectImageOrientationEnum,
+                            ImageClampingMode,
+                            const KURL& url) {
   {
     PaintCanvasAutoRestore ar(canvas, false);
     if (drawNeedsLayer(flags)) {
       SkRect layerRect = dstRect;
       canvas->saveLayer(&layerRect, &flags);
     }
-    sk_sp<PaintRecord> recording = builder.endRecording();
-    canvas->drawPicture(recording.get());
+
+    canvas->drawPicture(paintRecordForCurrentFrame(srcRect, dstRect, url));
   }
 
   // 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 {
   SVGSVGElement* rootElement = svgRootElement(m_page.get());
@@ skipping 213 matching lines @@
   }
 
   return m_page ? SizeAvailable : SizeUnavailable;
 }
 
 String SVGImage::filenameExtension() const {
   return "svg";
 }
 
 }  // namespace blink