Eliminate deferral overhead with canvas to canvas draws

Source/modules/canvas2d/CanvasRenderingContext2D.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2010 Nokia Corporation and/or its subsidiary(-ies)
  * Copyright (C) 2007 Alp Toker <alp@atoker.com>
  * Copyright (C) 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Dirk Schulze <krit@webkit.org>
  * Copyright (C) 2010 Torch Mobile (Beijing) Co. Ltd. All rights reserved.
  * Copyright (C) 2012, 2013 Intel Corporation. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
@@ skipping 861 matching lines @@
     c->saveLayer(nullptr, &compositePaint);
     SkPaint foregroundPaint = *state().getPaint(paintType, DrawForegroundOnly, imageType);
     foregroundPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
     c->setMatrix(ctm);
     drawFunc(c, &foregroundPaint);
     c->restore();
     c->setMatrix(ctm);
 }
 
 template<typename DrawFunc, typename ContainsFunc>
-bool CanvasRenderingContext2D::draw(const DrawFunc& drawFunc, const ContainsFunc& drawCoversClipBounds, CanvasDeferralMode deferralMode, const SkRect& bounds, CanvasRenderingContext2DState::PaintType paintType, CanvasRenderingContext2DState::ImageType imageType)
+bool CanvasRenderingContext2D::draw(const DrawFunc& drawFunc, const ContainsFunc& drawCoversClipBounds, const SkRect& bounds, CanvasRenderingContext2DState::PaintType paintType, CanvasRenderingContext2DState::ImageType imageType)
 {
     if (!state().isTransformInvertible())
         return false;
 
     SkIRect clipBounds;
-    // Deliberately not using 'deferralMode' in the call to drawingCanvas below because
-    // a) The call does not write anything so we do not care about the write mode here
-    // b) We want to avoid flushing before the call to checkOverdraw (below), otherwise
-    //    we could be supressing an overdraw optimization.
     if (!drawingCanvas()->getClipDeviceBounds(&clipBounds))
         return false;
 
     // If gradient size is zero, then paint nothing.
     CanvasStyle* style = state().style(paintType);
     if (style) {
         CanvasGradient* gradient = style->canvasGradient();
         if (gradient && gradient->gradient()->isZeroSize())
             return false;
     }
 
     if (isFullCanvasCompositeMode(state().globalComposite()) || state().hasFilter()) {
-        compositedDraw(drawFunc, drawingCanvas(deferralMode), paintType, imageType);
+        compositedDraw(drawFunc, drawingCanvas(), paintType, imageType);
         didDraw(clipBounds);
     } else if (state().globalComposite() == SkXfermode::kSrc_Mode) {
         clearCanvas(); // takes care of checkOvewrdraw()
         const SkPaint* paint = state().getPaint(paintType, DrawForegroundOnly, imageType);
-        drawFunc(drawingCanvas(deferralMode), paint);
+        drawFunc(drawingCanvas(), paint);
         didDraw(clipBounds);
     } else {
         SkIRect dirtyRect;
         if (computeDirtyRect(bounds, clipBounds, &dirtyRect)) {
             const SkPaint* paint = state().getPaint(paintType, DrawShadowAndForeground, imageType);
             if (paintType != CanvasRenderingContext2DState::StrokePaintType && drawCoversClipBounds(clipBounds))
                 checkOverdraw(bounds, paint, imageType, ClipFill);
-            drawFunc(drawingCanvas(deferralMode), paint);
+            drawFunc(drawingCanvas(), paint);
             didDraw(dirtyRect);
         }
     }
     return true;
 }
 
 static bool isPathExpensive(const Path& path)
 {
     const SkPath& skPath = path.skPath();
     if (ExpensiveCanvasHeuristicParameters::ConcavePathsAreExpensive && !skPath.isConvex())
@@ skipping 21 matching lines @@
         return;
 
     if (draw(
         [&skPath, this](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             c->drawPath(skPath, *paint);
         },
         [](const SkIRect& rect) // overdraw test lambda
         {
             return false;
-        }, AllowDeferredCanvas, bounds, paintType)) {
+        }, bounds, paintType)) {
         if (isPathExpensive(path)) {
             ImageBuffer* buffer = canvas()->buffer();
             if (buffer)
                 buffer->setHasExpensiveOp();
         }
     }
 }
 
 static SkPath::FillType parseWinding(const String& windingRuleString)
 {
@@ skipping 36 matching lines @@
 
     SkRect rect = SkRect::MakeXYWH(x, y, width, height);
     draw(
         [&rect, this](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             c->drawRect(rect, *paint);
         },
         [&rect, this](const SkIRect& clipBounds) // overdraw test lambda
         {
             return rectContainsTransformedRect(rect, clipBounds);
-        }, AllowDeferredCanvas, rect, CanvasRenderingContext2DState::FillPaintType);
+        }, rect, CanvasRenderingContext2DState::FillPaintType);
 }
 
 static void strokeRectOnCanvas(const FloatRect& rect, SkCanvas* canvas, const SkPaint* paint)
 {
     ASSERT(paint->getStyle() == SkPaint::kStroke_Style);
     if ((rect.width() > 0) != (rect.height() > 0)) {
         // When stroking, we must skip the zero-dimension segments
         SkPath path;
         path.moveTo(rect.x(), rect.y());
         path.lineTo(rect.maxX(), rect.maxY());
@@ skipping 16 matching lines @@
     FloatRect bounds = rect;
     inflateStrokeRect(bounds);
     draw(
         [&rect, this](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             strokeRectOnCanvas(rect, c, paint);
         },
         [](const SkIRect& clipBounds) // overdraw test lambda
         {
             return false;
-        }, AllowDeferredCanvas, bounds, CanvasRenderingContext2DState::StrokePaintType);
+        }, bounds, CanvasRenderingContext2DState::StrokePaintType);
 }
 
 void CanvasRenderingContext2D::clipInternal(const Path& path, const String& windingRuleString)
 {
     SkCanvas* c = drawingCanvas();
     if (!c) {
         return;
     }
     if (!state().isTransformInvertible()) {
         return;
@@ skipping 321 matching lines @@
     FloatRect srcRect = normalizeRect(FloatRect(sx, sy, sw, sh));
     FloatRect dstRect = normalizeRect(FloatRect(dx, dy, dw, dh));
 
     clipRectsToImageRect(FloatRect(FloatPoint(), imageSource->elementSize()), &srcRect, &dstRect);
 
     imageSource->adjustDrawRects(&srcRect, &dstRect);
 
     if (srcRect.isEmpty())
         return;
 
-    CanvasDeferralMode deferralMode = imageSource->isVideoElement() ? ForceImmediateCanvas : AllowDeferredCanvas;
+    // FIXME: crbug.com/447218

[Stephen White, 2015/08/14 15:10:48]

Nit: this bug is marked as fixed. Also, it's about display list canvas.
If it's the right bug, we should add a comment to say that it applies
to deferred canvas mode as well.

+    // We make the destination canvas fall out of display list mode by forcing
+    // immediate rendering. This is to prevent run-away memory consumption caused by SkSurface
+    // copyOnWrite when the source canvas is animated and consumed at a rate higher than the
+    // presentation frame rate of the destination canvas.
+    if (imageSource->isVideoElement() || imageSource->isCanvasElement())
+        canvas()->disableDeferral();
 
     validateStateStack();
 
     draw(
         [this, &imageSource, &image, &srcRect, dstRect](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             drawImageInternal(c, imageSource, image.get(), srcRect, dstRect, paint);
         },
         [this, &dstRect](const SkIRect& clipBounds) // overdraw test lambda
         {
             return rectContainsTransformedRect(dstRect, clipBounds);
-        }, deferralMode, dstRect, CanvasRenderingContext2DState::ImagePaintType,
+        }, dstRect, CanvasRenderingContext2DState::ImagePaintType,
         imageSource->isOpaque() ? CanvasRenderingContext2DState::OpaqueImage : CanvasRenderingContext2DState::NonOpaqueImage);
 
     validateStateStack();
 
     bool isExpensive = false;
 
     if (ExpensiveCanvasHeuristicParameters::SVGImageSourcesAreExpensive && image && image->isSVGImage())
         isExpensive = true;
 
     if (imageSource->elementSize().width() * imageSource->elementSize().height() > canvas()->width() * canvas()->height() * ExpensiveCanvasHeuristicParameters::ExpensiveImageSizeRatio)
         isExpensive = true;
 
     if (isExpensive) {
         ImageBuffer* buffer = canvas()->buffer();
         if (buffer)
             buffer->setHasExpensiveOp();
     }
 
-    if (imageSource->isCanvasElement()) {
-        if (static_cast<HTMLCanvasElement*>(imageSource)->is3D()) {
-            // WebGL to 2D canvas: must flush graphics context to prevent a race
-            // FIXME: crbug.com/516331 Fix the underlying synchronization issue so this flush can be eliminated.
-            canvas()->buffer()->flushGpu();
-        } else {
-            // FIXME: crbug.com/447218
-            // We make the destination canvas fall out of display list mode by calling
-            // flush. This is to prevent run-away memory consumption caused by SkSurface
-            // copyOnWrite when the source canvas is animated and consumed at a rate higher than the
-            // presentation frame rate of the destination canvas.
-            canvas()->buffer()->flush();
-        }
+    if (imageSource->isCanvasElement() && static_cast<HTMLCanvasElement*>(imageSource)->is3D()) {
+        // WebGL to 2D canvas: must flush graphics context to prevent a race
+        // FIXME: crbug.com/516331 Fix the underlying synchronization issue so this flush can be eliminated.
+        canvas()->buffer()->flushGpu();
     }
 
     if (canvas()->originClean() && wouldTaintOrigin(imageSource))
         canvas()->setOriginTainted();
 }
 
 void CanvasRenderingContext2D::clearCanvas()
 {
     FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height());
     checkOverdraw(canvasRect, 0, CanvasRenderingContext2DState::NoImage, ClipFill);
-    if (drawingCanvas())
-        drawingCanvas()->clear(m_hasAlpha ? SK_ColorTRANSPARENT : SK_ColorBLACK);
+    SkCanvas* c = drawingCanvas();
+    if (c)
+        c->clear(m_hasAlpha ? SK_ColorTRANSPARENT : SK_ColorBLACK);
 }
 
 bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const SkIRect& transformedRect) const
 {
     FloatQuad quad(rect);
     FloatQuad transformedQuad(FloatRect(transformedRect.x(), transformedRect.y(), transformedRect.width(), transformedRect.height()));
     return state().transform().mapQuad(quad).containsQuad(transformedQuad);
 }
 
 CanvasGradient* CanvasRenderingContext2D::createLinearGradient(float x0, float y0, float x1, float y1)
@@ skipping 85 matching lines @@
 
     if (ExpensiveCanvasHeuristicParameters::BlurredShadowsAreExpensive && state().shouldDrawShadows() && state().shadowBlur() > 0) {
         ImageBuffer* buffer = canvas()->buffer();
         if (buffer)
             buffer->setHasExpensiveOp();
     }
 
     canvas()->didDraw(SkRect::Make(dirtyRect));
 }
 
-SkCanvas* CanvasRenderingContext2D::drawingCanvas(CanvasDeferralMode deferralMode) const
+SkCanvas* CanvasRenderingContext2D::drawingCanvas() const
 {
     if (isContextLost())
         return nullptr;
-    return deferralMode == ForceImmediateCanvas ? canvas()->immediateDrawingCanvas() : canvas()->drawingCanvas();
+    return canvas()->drawingCanvas();
 }
 
 ImageData* CanvasRenderingContext2D::createImageData(ImageData* imageData) const
 {
     return ImageData::create(imageData->size());
 }
 
 ImageData* CanvasRenderingContext2D::createImageData(float sw, float sh, ExceptionState& exceptionState) const
 {
     if (!sw || !sh) {
@@ skipping 442 matching lines @@
 
     draw(
         [&font, this, &textRunPaintInfo, &location](SkCanvas* c, const SkPaint* paint) // draw lambda
         {
             font.drawBidiText(c, textRunPaintInfo, location, Font::UseFallbackIfFontNotReady, cDeviceScaleFactor, *paint);
         },
         [](const SkIRect& rect) // overdraw test lambda
         {
             return false;
         },
-        AllowDeferredCanvas, textRunPaintInfo.bounds, paintType);
+        textRunPaintInfo.bounds, paintType);
 }
 
 void CanvasRenderingContext2D::inflateStrokeRect(FloatRect& rect) const
 {
     // Fast approximation of the stroke's bounding rect.
     // This yields a slightly oversized rect but is very fast
     // compared to Path::strokeBoundingRect().
     static const float root2 = sqrtf(2);
     float delta = state().lineWidth() / 2;
     if (state().lineJoin() == MiterJoin)
@@ skipping 283 matching lines @@
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink