Rounded background image fast path

third_party/WebKit/Source/core/paint/BoxPainter.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/BoxPainter.h"
 
 #include "core/HTMLNames.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/ImageQualityController.h"
@@ skipping 179 matching lines @@
 
     for (auto it = reversedPaintList.rbegin(); it != reversedPaintList.rend(); ++it)
         paintFillLayer(m_layoutBox, paintInfo, c, **it, rect, bleedAvoidance, 0, LayoutSize(), op, backgroundObject);
 
     if (shouldDrawBackgroundInSeparateBuffer)
         context.endLayer();
 }
 
 namespace {
 
-void applyBoxShadowForBackground(GraphicsContext& context, const LayoutObject& obj)
-{
-    const ShadowList* shadowList = obj.style()->boxShadow();
-    ASSERT(shadowList);
-    for (size_t i = shadowList->shadows().size(); i--; ) {
-        const ShadowData& boxShadow = shadowList->shadows()[i];
-        if (boxShadow.style() != Normal)
-            continue;
-        FloatSize shadowOffset(boxShadow.x(), boxShadow.y());
-        context.setShadow(shadowOffset, boxShadow.blur(),
-            boxShadow.color().resolve(obj.resolveColor(CSSPropertyColor)),
-            DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha);
-        return;
+// RAII shadow helper.
+class ShadowContext {
+    STACK_ALLOCATED();
+public:
+    ShadowContext(GraphicsContext& context, const LayoutObject& obj, bool applyShadow)
+        : m_saver(context, applyShadow)
+    {
+        if (!applyShadow)
+            return;
+
+        const ShadowList* shadowList = obj.style()->boxShadow();
+        DCHECK(shadowList);
+        for (size_t i = shadowList->shadows().size(); i--; ) {
+            const ShadowData& boxShadow = shadowList->shadows()[i];
+            if (boxShadow.style() != Normal)
+                continue;
+            FloatSize shadowOffset(boxShadow.x(), boxShadow.y());
+            context.setShadow(shadowOffset, boxShadow.blur(),
+                boxShadow.color().resolve(obj.resolveColor(CSSPropertyColor)),
+                DrawLooperBuilder::ShadowRespectsTransforms, DrawLooperBuilder::ShadowIgnoresAlpha);
+            break;
+        }
     }
-}
+
+private:
+    GraphicsContextStateSaver m_saver;
+};
 
 FloatRoundedRect getBackgroundRoundedRect(const LayoutObject& obj, const LayoutRect& borderRect,
     const InlineFlowBox* box, LayoutUnit inlineBoxWidth, LayoutUnit inlineBoxHeight,
     bool includeLogicalLeftEdge, bool includeLogicalRightEdge)
 {
     FloatRoundedRect border = obj.style()->getRoundedBorderFor(borderRect, includeLogicalLeftEdge, includeLogicalRightEdge);
     if (box && (box->nextLineBox() || box->prevLineBox())) {
         FloatRoundedRect segmentBorder = obj.style()->getRoundedBorderFor(LayoutRect(0, 0, inlineBoxWidth, inlineBoxHeight),
             includeLogicalLeftEdge, includeLogicalRightEdge);
         border.setRadii(segmentBorder.getRadii());
@@ skipping 89 matching lines @@
     bool isBottomLayer;
     bool isBorderFill;
     bool isClippedWithLocalScrolling;
     bool isRoundedFill;
 
     bool shouldPaintImage;
     bool shouldPaintColor;
     bool shouldPaintShadow;
 };
 
+// RAII image paint helper.
+class ImagePaintContext {
+    STACK_ALLOCATED();
+public:
+    ImagePaintContext(const LayoutBoxModelObject& obj, GraphicsContext& context,
+        const FillLayer& layer, const StyleImage& styleImage, SkXfermode::Mode op,
+        const LayoutObject* backgroundObject, const LayoutSize& containerSize)
+        : m_context(context)
+        , m_previousInterpolationQuality(context.imageInterpolationQuality())
+    {
+        SkXfermode::Mode bgOp = WebCoreCompositeToSkiaComposite(layer.composite(), layer.blendMode());
+        // if op != SkXfermode::kSrcOver_Mode, a mask is being painted.
+        m_compositeOp = (op == SkXfermode::kSrcOver_Mode) ? bgOp : op;
+
+        const LayoutObject& imageClient = backgroundObject ? *backgroundObject : obj;
+        m_image = styleImage.image(imageClient, flooredIntSize(containerSize), obj.style()->effectiveZoom());
+
+        m_interpolationQuality =
+            BoxPainter::chooseInterpolationQuality(imageClient, m_image.get(), &layer, containerSize);
+        if (m_interpolationQuality != m_previousInterpolationQuality)
+            context.setImageInterpolationQuality(m_interpolationQuality);
+
+        if (layer.maskSourceType() == MaskLuminance)
+            context.setColorFilter(ColorFilterLuminanceToAlpha);
+    }
+
+    ~ImagePaintContext()
+    {
+        if (m_interpolationQuality != m_previousInterpolationQuality)
+            m_context.setImageInterpolationQuality(m_previousInterpolationQuality);
+    }
+
+    Image* image() const { return m_image.get(); }
+
+    SkXfermode::Mode compositeOp() const { return m_compositeOp; }
+
+private:
+    RefPtr<Image> m_image;
+    GraphicsContext& m_context;
+    SkXfermode::Mode m_compositeOp;
+    InterpolationQuality m_interpolationQuality;
+    InterpolationQuality m_previousInterpolationQuality;
+};
+
 inline bool paintFastBottomLayer(const LayoutBoxModelObject& obj, const PaintInfo& paintInfo,
-    const FillLayerInfo& info, const LayoutRect& rect, BackgroundBleedAvoidance bleedAvoidance,
-    const InlineFlowBox* box, const LayoutSize& boxSize)
+    const FillLayerInfo& info, const FillLayer& layer, const LayoutRect& rect,
+    BackgroundBleedAvoidance bleedAvoidance, const InlineFlowBox* box, const LayoutSize& boxSize,
+    SkXfermode::Mode op, const LayoutObject* backgroundObject,
+    Optional<BackgroundImageGeometry>& geometry)
 {
     // Complex cases not handled on the fast path.
     if (!info.isBottomLayer || !info.isBorderFill || info.isClippedWithLocalScrolling)
         return false;
 
-    // Not yet.
-    if (info.image)
-        return false;
-
     // Transparent layer, nothing to paint.
-    if (!info.shouldPaintColor)
+    if (!info.shouldPaintColor && !info.shouldPaintImage)
         return true;
 
+    // When the layer has an image, figure out whether it is covered by a single tile.
+    FloatRect imageTile;
+    if (info.shouldPaintImage) {
+        DCHECK(!geometry);
+        geometry.emplace();
+        geometry->calculate(obj, paintInfo.paintContainer(), paintInfo.getGlobalPaintFlags(), layer, rect);
+
+        if (!geometry->destRect().isEmpty()) {

[chrishtr, 2016/05/20 15:44:13]

It's not so good that this code duplicates information that is
implicitly already in Image. It seems there should be a method
there called something like computeTiles, and another one called
drawWithTiles that uses the results of computeTiles. And it
should be unittested.

WDYT?

[f(malita), 2016/05/20 19:17:11]

Agreed.

The current API is convoluted and hard to follow, and my dirty little secret is
I'm planning to take a stab at ripping all the image drawing code out of Blink
in favor of a specialized DrawImageDisplayItem (essentially move all the image
draw/tiling logic to CC/display item impl).  So I'm not terribly excited about
spending too much time refactoring image tiling in Blink :)

Would it be OK to just share the existing code from Image via helpers for now? 
PTAL at PS#25

[chrishtr, 2016/05/20 19:52:35]

Sounds like a lot of work. Have you sketched it out? We should VC to talk about
it some before investing that much work.
Ok.

[f(malita), 2016/05/22 14:04:06]

I do expect it to be quite a bit of work, but a) I think the end result will be
worth it
and b) I'm hoping once we have a basic skeleton in place we can transition
gradually
(no mega-CL to break the world).

We can certainly VC, on we can talk about it at BlinkOn (planning to put
together a rough
plan and prototype by then).

[chrishtr, 2016/05/23 19:59:22]

Talking about it at BlinkOn sounds good.

+            // The tile is too small.
+            if (geometry->tileSize().width() < rect.width() || geometry->tileSize().height() < rect.height())
+                return false;
+
+            const FloatRect destRect(geometry->destRect());
+            const FloatPoint srcPoint(geometry->phase());
+
+            // This duplicates Image::drawTiled() logic.
+            // TODO(fmalita): find a way to share?
+            const FloatSize actualTileSize(geometry->tileSize() + geometry->spaceSize());
+            imageTile.setLocation(FloatPoint(
+                destRect.x() + fmodf(fmodf(-srcPoint.x(), actualTileSize.width()) - actualTileSize.width(), actualTileSize.width()),
+                destRect.y() + fmodf(fmodf(-srcPoint.y(), actualTileSize.height()) - actualTileSize.height(), actualTileSize.height())
+            ));
+            imageTile.setSize(FloatSize(geometry->tileSize()));
+
+            // The tile is misaligned.
+            if (!imageTile.contains(FloatRect(rect)))
+                return false;
+        }
+    }
+
+    // At this point we're committed to the fast path: the destination (r)rect fits within a single
+    // tile, and we can paint it using direct draw(R)Rect() calls.
     GraphicsContext& context = paintInfo.context;
-    GraphicsContextStateSaver shadowStateSaver(context, info.shouldPaintShadow);
-    if (info.shouldPaintShadow)
-        applyBoxShadowForBackground(context, obj);
+    FloatRoundedRect border = info.isRoundedFill
+        ? backgroundRoundedRectAdjustedForBleedAvoidance(obj, rect, bleedAvoidance, box, boxSize, info.includeLeftEdge, info.includeRightEdge)
+        : FloatRoundedRect(pixelSnappedIntRect(rect));
 
-    if (info.isRoundedFill) {
-        FloatRoundedRect border = backgroundRoundedRectAdjustedForBleedAvoidance(obj, rect,
-            bleedAvoidance, box, boxSize, info.includeLeftEdge, info.includeRightEdge);
+    Optional<RoundedInnerRectClipper> clipper;
+    if (info.isRoundedFill && !border.isRenderable()) {
+        // When the rrect is not renderable, we resort to clipping.
+        // RoundedInnerRectClipper handles this case via discrete, corner-wise clipping.
+        clipper.emplace(obj, paintInfo, rect, border, ApplyToContext);
+        border.setRadii(FloatRoundedRect::Radii());
+    }
 
-        if (border.isRenderable()) {
-            context.fillRoundedRect(border, info.color);
-        } else {
-            RoundedInnerRectClipper clipper(obj, paintInfo, rect, border, ApplyToContext);
-            context.fillRect(border.rect(), info.color);
-        }
-    } else {
-        context.fillRect(pixelSnappedIntRect(rect), info.color);
+    // Paint the color + shadow if needed.
+    if (info.shouldPaintColor) {
+        const ShadowContext shadowContext(context, obj, info.shouldPaintShadow);
+        context.fillRoundedRect(border, info.color);
     }
 
+    // Paint the image + shadow if needed.
+    if (!info.shouldPaintImage || imageTile.isEmpty())
+        return true;
+
+    const ImagePaintContext imageContext(obj, context, layer, *info.image, op, backgroundObject,
+        geometry->tileSize());
+    if (!imageContext.image())
+        return true;
+
+    // Compute the image src rect (tile subset) which gets mapped onto the dest/border rect.
+    // TODO(fmalita): share with Image::drawTiled()?
+    const FloatSize intrinsicTileSize = imageContext.image()->hasRelativeSize()
+        ? imageTile.size()
+        : FloatSize(imageContext.image()->size());
+    const FloatSize tileScale(
+        intrinsicTileSize.width() / imageTile.width(),
+        intrinsicTileSize.height() / imageTile.height());
+    FloatRect srcRect = border.rect();
+    srcRect.moveBy(-imageTile.location());
+    srcRect.scale(tileScale.width(), tileScale.height());
+
+    // The shadow may have been applied with the color fill.
+    const ShadowContext shadowContext(context, obj, info.shouldPaintShadow && !info.shouldPaintColor);
+    TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "PaintImage", "data",
+        InspectorPaintImageEvent::data(obj, *info.image));
+    context.drawImageRRect(imageContext.image(), border, &srcRect, imageContext.compositeOp());
+
     return true;
 }
 
 } // anonymous namespace
 
 void BoxPainter::paintFillLayer(const LayoutBoxModelObject& obj, const PaintInfo& paintInfo, const Color& color, const FillLayer& bgLayer, const LayoutRect& rect, BackgroundBleedAvoidance bleedAvoidance, const InlineFlowBox* box, const LayoutSize& boxSize, SkXfermode::Mode op, const LayoutObject* backgroundObject)
 {
     GraphicsContext& context = paintInfo.context;
     if (rect.isEmpty())
         return;
 
     const FillLayerInfo info(obj, color, bgLayer, bleedAvoidance, box);
+    Optional<BackgroundImageGeometry> geometry;
 
     // Fast path for drawing simple color backgrounds.
-    if (paintFastBottomLayer(obj, paintInfo, info, rect, bleedAvoidance, box, boxSize))
+    if (paintFastBottomLayer(obj, paintInfo, info, bgLayer, rect, bleedAvoidance, box, boxSize, op,
+        backgroundObject, geometry)) {
         return;
+    }
 
     Optional<RoundedInnerRectClipper> clipToBorder;
     if (info.isRoundedFill) {
         FloatRoundedRect border = info.isBorderFill
             ? backgroundRoundedRectAdjustedForBleedAvoidance(obj, rect, bleedAvoidance, box, boxSize, info.includeLeftEdge, info.includeRightEdge)
             : getBackgroundRoundedRect(obj, rect, box, boxSize.width(), boxSize.height(), info.includeLeftEdge, info.includeRightEdge);
 
         // Clip to the padding or content boxes as necessary.
         if (bgLayer.clip() == ContentFillBox) {
             border = obj.style()->getRoundedInnerBorderFor(LayoutRect(border.rect()),
@@ skipping 70 matching lines @@
         ASSERT_NOT_REACHED();
         break;
     }
 
     // Paint the color first underneath all images, culled if background image occludes it.
     // TODO(trchen): In the !bgLayer.hasRepeatXY() case, we could improve the culling test
     // by verifying whether the background image covers the entire painting area.
     if (info.isBottomLayer && info.color.alpha()) {
         IntRect backgroundRect(pixelSnappedIntRect(scrolledPaintRect));
         if (info.shouldPaintColor || info.shouldPaintShadow)  {
-            GraphicsContextStateSaver shadowStateSaver(context, info.shouldPaintShadow);
-            if (info.shouldPaintShadow)
-                applyBoxShadowForBackground(context, obj);
-
+            const ShadowContext shadowContext(context, obj, info.shouldPaintShadow);
             context.fillRect(backgroundRect, info.color);
         }
     }
 
     // no progressive loading of the background image
     if (info.shouldPaintImage) {
-        BackgroundImageGeometry geometry;
-        geometry.calculate(obj, paintInfo.paintContainer(), paintInfo.getGlobalPaintFlags(), bgLayer, scrolledPaintRect);
+        if (!geometry) {
+            geometry.emplace();
+            geometry->calculate(obj, paintInfo.paintContainer(), paintInfo.getGlobalPaintFlags(), bgLayer, scrolledPaintRect);
+        } else {
+            // The geometry was calculated in paintFastBottomLayer().
+            DCHECK(info.isBottomLayer && info.isBorderFill && !info.isClippedWithLocalScrolling);
+        }
 
-        if (!geometry.destRect().isEmpty()) {
-            SkXfermode::Mode bgOp = WebCoreCompositeToSkiaComposite(bgLayer.composite(), bgLayer.blendMode());
-            // if op != SkXfermode::kSrcOver_Mode, a mask is being painted.
-            SkXfermode::Mode compositeOp = op == SkXfermode::kSrcOver_Mode ? bgOp : op;
-            const LayoutObject& clientForBackgroundImage = backgroundObject ? *backgroundObject : obj;
-            RefPtr<Image> image = info.image->image(clientForBackgroundImage, flooredIntSize(geometry.tileSize()), obj.style()->effectiveZoom());
-            InterpolationQuality interpolationQuality = chooseInterpolationQuality(clientForBackgroundImage, image.get(), &bgLayer, LayoutSize(geometry.tileSize()));
-            if (bgLayer.maskSourceType() == MaskLuminance)
-                context.setColorFilter(ColorFilterLuminanceToAlpha);
-            InterpolationQuality previousInterpolationQuality = context.imageInterpolationQuality();
-            context.setImageInterpolationQuality(interpolationQuality);
-            TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "PaintImage", "data", InspectorPaintImageEvent::data(obj, *info.image));
-            context.drawTiledImage(image.get(), FloatRect(geometry.destRect()), FloatPoint(geometry.phase()), FloatSize(geometry.tileSize()),
-                compositeOp, FloatSize(geometry.spaceSize()));
-            context.setImageInterpolationQuality(previousInterpolationQuality);
+        if (!geometry->destRect().isEmpty()) {
+            const ImagePaintContext imageContext(obj, context, bgLayer, *info.image, op,
+                backgroundObject, geometry->tileSize());
+            TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "PaintImage", "data",
+                InspectorPaintImageEvent::data(obj, *info.image));
+            context.drawTiledImage(imageContext.image(), FloatRect(geometry->destRect()),
+                FloatPoint(geometry->phase()), FloatSize(geometry->tileSize()),
+                imageContext.compositeOp(), FloatSize(geometry->spaceSize()));
         }
     }
 
     if (bgLayer.clip() == TextFillBox) {
         // Create the text mask layer.
         context.beginLayer(1, SkXfermode::kDstIn_Mode);
 
         // Now draw the text into the mask. We do this by painting using a special paint phase that signals to
         // InlineTextBoxes that they should just add their contents to the clip.
         PaintInfo info(context, maskRect, PaintPhaseTextClip, GlobalPaintNormalPhase, 0);
@@ skipping 218 matching lines @@
     }
 }
 
 bool BoxPainter::shouldForceWhiteBackgroundForPrintEconomy(const ComputedStyle& style, const Document& document)
 {
     return document.printing() && style.getPrintColorAdjust() == PrintColorAdjustEconomy
         && (!document.settings() || !document.settings()->shouldPrintBackgrounds());
 }
 
 } // namespace blink