Move overdraw tracking code from GraphicsContext to CanvasRenderingContext2D

Source/core/html/canvas/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 72 matching lines @@
 static const char ltr[] = "ltr";
 static const double TryRestoreContextInterval = 0.5;
 static const unsigned MaxTryRestoreContextAttempts = 4;
 static const unsigned FetchedFontsCacheLimit = 50;
 
 static bool contextLostRestoredEventsEnabled()
 {
     return RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
 }
 
+// Drawing methods need to use this instead of SkAutoCanvasRestore in case overdraw
+// detection substitutes the recording canvas (to discard overdrawn draw calls).
+class CanvasRenderingContext2DAutoRestoreSkCanvas {
+public:
+    CanvasRenderingContext2DAutoRestoreSkCanvas(CanvasRenderingContext2D* context)
+        : m_context(context)
+    {
+        ASSERT(m_context);
+        SkCanvas* c = m_context->drawingCanvas();
+        if (c) {
+            m_saveCount = c->getSaveCount();
+        }
+    }
+
+    ~CanvasRenderingContext2DAutoRestoreSkCanvas()
+    {
+        SkCanvas* c = m_context->drawingCanvas();
+        if (c)
+            c->restoreToCount(m_saveCount);
+        m_context->validateStateStack();
+    }
+private:
+    CanvasRenderingContext2D* m_context;
+    int m_saveCount;
+};
+
 CanvasRenderingContext2D::CanvasRenderingContext2D(HTMLCanvasElement* canvas, const CanvasContextCreationAttributes& attrs, Document& document)
     : CanvasRenderingContext(canvas)
     , m_usesCSSCompatibilityParseMode(document.inQuirksMode())
     , m_clipAntialiasing(NotAntiAliased)
     , m_hasAlpha(attrs.alpha())
     , m_isContextLost(false)
     , m_contextRestorable(true)
     , m_tryRestoreContextAttemptCount(0)
     , m_dispatchContextLostEventTimer(this, &CanvasRenderingContext2D::dispatchContextLostEvent)
     , m_dispatchContextRestoredEventTimer(this, &CanvasRenderingContext2D::dispatchContextRestoredEvent)
@@ skipping 173 matching lines @@
     , m_globalComposite(SkXfermode::kSrcOver_Mode)
     , m_invertibleCTM(true)
     , m_lineDashOffset(0)
     , m_imageSmoothingEnabled(true)
     , m_textAlign(StartTextAlign)
     , m_textBaseline(AlphabeticTextBaseline)
     , m_direction(DirectionInherit)
     , m_unparsedFont(defaultFont)
     , m_realizedFont(false)
     , m_hasClip(false)
+    , m_hasComplexClip(false)
 {
 }
 
 CanvasRenderingContext2D::State::State(const State& other, ClipListCopyMode mode)
     : CSSFontSelectorClient()
     , m_unrealizedSaveCount(other.m_unrealizedSaveCount)
     , m_unparsedStrokeColor(other.m_unparsedStrokeColor)
     , m_unparsedFillColor(other.m_unparsedFillColor)
     , m_strokeStyle(other.m_strokeStyle)
     , m_fillStyle(other.m_fillStyle)
@@ skipping 10 matching lines @@
     , m_invertibleCTM(other.m_invertibleCTM)
     , m_lineDashOffset(other.m_lineDashOffset)
     , m_imageSmoothingEnabled(other.m_imageSmoothingEnabled)
     , m_textAlign(other.m_textAlign)
     , m_textBaseline(other.m_textBaseline)
     , m_direction(other.m_direction)
     , m_unparsedFont(other.m_unparsedFont)
     , m_font(other.m_font)
     , m_realizedFont(other.m_realizedFont)
     , m_hasClip(other.m_hasClip)
+    , m_hasComplexClip(other.m_hasComplexClip)
 {
     if (mode == CopyClipList) {
         m_clipList = other.m_clipList;
     }
     if (m_realizedFont)
         static_cast<CSSFontSelector*>(m_font.fontSelector())->registerForInvalidationCallbacks(this);
 }
 
 CanvasRenderingContext2D::State& CanvasRenderingContext2D::State::operator=(const State& other)
 {
@@ skipping 22 matching lines @@
     m_transform = other.m_transform;
     m_invertibleCTM = other.m_invertibleCTM;
     m_imageSmoothingEnabled = other.m_imageSmoothingEnabled;
     m_textAlign = other.m_textAlign;
     m_textBaseline = other.m_textBaseline;
     m_direction = other.m_direction;
     m_unparsedFont = other.m_unparsedFont;
     m_font = other.m_font;
     m_realizedFont = other.m_realizedFont;
     m_hasClip = other.m_hasClip;
+    m_hasComplexClip = other.m_hasComplexClip;
     m_clipList = other.m_clipList;
 
     if (m_realizedFont)
         static_cast<CSSFontSelector*>(m_font.fontSelector())->registerForInvalidationCallbacks(this);
 
     return *this;
 }
 
 CanvasRenderingContext2D::State::~State()
 {
@@ skipping 167 matching lines @@
     } else if (style.isCanvasPattern()) {
         RefPtrWillBeRawPtr<CanvasPattern> canvasPattern = style.getAsCanvasPattern();
 
         if (canvas()->originClean() && !canvasPattern->originClean())
             canvas()->setOriginTainted();
 
         canvasStyle = CanvasStyle::createFromPattern(canvasPattern);
     }
 
     ASSERT(canvasStyle);
-
     SkCanvas* c = drawingCanvas();
-    realizeSaves(c);
-    modifiableState().m_fillStyle = canvasStyle.release();
     if (!c)
         return;
+    realizeSaves(c);
+
+    modifiableState().m_fillStyle = canvasStyle.release();
+    modifiableState().m_unparsedFillColor = colorString;
     state().m_fillStyle->applyFillColor(drawingContext());
-    modifiableState().m_unparsedFillColor = colorString;
 }
 
 float CanvasRenderingContext2D::lineWidth() const
 {
     return state().m_lineWidth;
 }
 
 void CanvasRenderingContext2D::setLineWidth(float width)
 {
     if (!std::isfinite(width) || width <= 0)
@@ skipping 552 matching lines @@
 
     SkPath skPath = path.skPath();
     skPath.setFillType(parseWinding(windingRuleString));
     ImageBuffer* buffer = canvas()->buffer();
     if (buffer && buffer->needsClipTracking()) {
         modifiableState().m_clipList.clipPath(skPath, m_clipAntialiasing, affineTransformToSkMatrix(state().m_transform));
     }
 
     c->clipPath(skPath, SkRegion::kIntersect_Op, m_clipAntialiasing == AntiAliased);
     if (!skPath.isRect(0))
-        drawingContext()->setHasComplexClip();
+        modifiableState().m_hasComplexClip = true;
     modifiableState().m_hasClip = true;
 }
 
 void CanvasRenderingContext2D::clip(const String& windingRuleString)
 {
     clipInternal(m_path, windingRuleString);
 }
 
 void CanvasRenderingContext2D::clip(Path2D* domPath, const String& windingRuleString)
 {
@@ skipping 93 matching lines @@
         pathRect, ScrollAlignment::alignCenterAlways, ScrollAlignment::alignTopAlways);
 
     // TODO: should implement "inform the user" that the caret and/or
     // selection the specified rectangle of the canvas. See http://crbug.com/357987
 }
 
 void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
 {
     if (!validateRectForCanvas(x, y, width, height))
         return;
-    GraphicsContext* context = drawingContext();
-    if (!context)
+
+    GraphicsContext* c = drawingContext();
+    if (!c)
         return;
     if (!state().m_invertibleCTM)
         return;
-    FloatRect rect(x, y, width, height);
 
-    FloatRect dirtyRect;
-    if (!computeDirtyRect(rect, &dirtyRect))
-        return;
+    c->clearShadow();
+    c->setAlphaAsFloat(1);
+    c->setCompositeOperation(SkXfermode::kClear_Mode);
 
-    context->clearShadow();
-    context->setAlphaAsFloat(1);
-    context->setCompositeOperation(SkXfermode::kSrcOver_Mode);
-
-    context->clearRect(rect);
-    if (m_hitRegionManager)
-        m_hitRegionManager->removeHitRegionsInRect(rect, state().m_transform);
+    // call to didDraw is taken care of in fillRect
+    fillRect(x, y, width, height);
 
     applyShadow(DrawShadowAndForeground);
-    context->setAlphaAsFloat(state().m_globalAlpha);
-    context->setCompositeOperation(state().m_globalComposite);
+    c->setAlphaAsFloat(state().m_globalAlpha);
+    c->setCompositeOperation(state().m_globalComposite);
 
-    validateStateStack();
-    didDraw(dirtyRect);
+    if (m_hitRegionManager) {
+        FloatRect rect(x, y, width, height);
+        m_hitRegionManager->removeHitRegionsInRect(rect, state().m_transform);
+    }
 }
 
 // FIXME(crbug.com/425531): Funtional.h cannot handle override function signature.
 static void fillRectOnContext(GraphicsContext* context, const FloatRect& rect)
 {
     context->fillRect(rect);
 }
 
 static void strokeRectOnContext(GraphicsContext* context, const FloatRect& rect)
 {
@@ skipping 16 matching lines @@
 
     // from the HTML5 Canvas spec:
     // If x0 = x1 and y0 = y1, then the linear gradient must paint nothing
     // If x0 = x1 and y0 = y1 and r0 = r1, then the radial gradient must paint nothing
     Gradient* gradient = c->fillGradient();
     if (gradient && gradient->isZeroSize())
         return;
 
     FloatRect rect(x, y, width, height);
     if (rectContainsTransformedRect(rect, clipBounds)) {
+        checkOverdraw(rect, &c->fillPaint(), NoImage, ClipFill);
         c->fillRect(rect);
         didDraw(clipBounds);
     } else if (isFullCanvasCompositeMode(state().m_globalComposite)) {
         fullCanvasCompositedDraw(bind(&fillRectOnContext, c, rect));
         didDraw(clipBounds);
     } else if (state().m_globalComposite == SkXfermode::kSrc_Mode) {
         clearCanvas();
-        c->clearShadow();
+        c->clearShadow(); // Takes care of signaling the overdraw
         c->fillRect(rect);
         applyShadow(DrawShadowAndForeground);
         didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
         if (computeDirtyRect(rect, clipBounds, &dirtyRect)) {
             c->fillRect(rect);
             didDraw(dirtyRect);
         }
     }
@@ skipping 100 matching lines @@
         return value.getAsImageBitmap().get();
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource, float x, float y, ExceptionState& exceptionState)
 {
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
     FloatSize sourceRectSize = imageSourceInternal->sourceSize();
     FloatSize destRectSize = imageSourceInternal->defaultDestinationSize();
-    drawImageInternal(imageSourceInternal, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, destRectSize.width(), destRectSize.height(), exceptionState);
+    drawImage(imageSourceInternal, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, destRectSize.width(), destRectSize.height(), exceptionState);
 }
 
 void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource,
     float x, float y, float width, float height, ExceptionState& exceptionState)
 {
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
     FloatSize sourceRectSize = imageSourceInternal->sourceSize();
-    drawImageInternal(imageSourceInternal, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, width, height, exceptionState);
+    drawImage(imageSourceInternal, 0, 0, sourceRectSize.width(), sourceRectSize.height(), x, y, width, height, exceptionState);
 }
 
 void CanvasRenderingContext2D::drawImage(const CanvasImageSourceUnion& imageSource,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
 {
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
-    drawImageInternal(imageSourceInternal, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState);
+    drawImage(imageSourceInternal, sx, sy, sw, sh, dx, dy, dw, dh, exceptionState);
 }
 
 static void drawVideo(SkCanvas* c, GraphicsContext* gc, CanvasImageSource* imageSource, FloatRect srcRect, FloatRect dstRect)
 {
     HTMLVideoElement* video = static_cast<HTMLVideoElement*>(imageSource);
     c->save();
     c->clipRect(WebCoreFloatRectToSKRect(dstRect));
     c->translate(dstRect.x(), dstRect.y());
     c->scale(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height());
     c->translate(-srcRect.x(), -srcRect.y());
     video->paintCurrentFrameInContext(gc, IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())));
     c->restore();
 }
 
 static void drawImageOnContext(SkCanvas* c, GraphicsContext* gc, CanvasImageSource* imageSource, Image* image, const FloatRect& srcRect, const FloatRect& dstRect)
 {
     if (!imageSource->isVideoElement()) {
         gc->drawImage(image, dstRect, srcRect, gc->compositeOperation());
     } else {
         drawVideo(c, gc, static_cast<HTMLVideoElement*>(imageSource), srcRect, dstRect);
     }
 }
 
-void CanvasRenderingContext2D::drawImageInternal(CanvasImageSource* imageSource,
+void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,
     float sx, float sy, float sw, float sh,
     float dx, float dy, float dw, float dh, ExceptionState& exceptionState)
 {
     RefPtr<Image> image;
     SourceImageStatus sourceImageStatus = InvalidSourceImageStatus;
     if (!imageSource->isVideoElement()) {
         SourceImageMode mode = canvas() == imageSource ? CopySourceImageIfVolatile : DontCopySourceImage; // Thunking for ==
         image = imageSource->getSourceImageForCanvas(mode, &sourceImageStatus);
         if (sourceImageStatus == UndecodableSourceImageStatus)
             exceptionState.throwDOMException(InvalidStateError, "The HTMLImageElement provided is in the 'broken' state.");
@@ skipping 32 matching lines @@
 
     // FIXME: crbug.com/447218
     // We make the destination canvas fall out of display list mode by calling
     // willAccessPixels. 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->isCanvasElement())
         canvas()->buffer()->willAccessPixels();
 
     if (rectContainsTransformedRect(dstRect, clipBounds)) {
+        checkOverdraw(dstRect, &c->fillPaint(), imageSource->isOpaque() ? OpaqueImage : NonOpaqueImage, ClipFill);
         drawImageOnContext(drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect);
         didDraw(clipBounds);
     } else if (isFullCanvasCompositeMode(state().m_globalComposite)) {
         fullCanvasCompositedDraw(bind(&drawImageOnContext, drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect));
         didDraw(clipBounds);
     } else if (state().m_globalComposite == SkXfermode::kSrc_Mode) {
-        clearCanvas();
+        clearCanvas(); // takes care of signaling an overdraw
         drawImageOnContext(drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect);
         didDraw(clipBounds);
     } else {
         FloatRect dirtyRect;
         if (computeDirtyRect(dstRect, clipBounds, &dirtyRect)) {
             drawImageOnContext(drawingCanvas(), c, imageSource, image.get(), srcRect, dstRect);
             didDraw(dirtyRect);
         }
     }
 
     validateStateStack();
 
     if (sourceImageStatus == ExternalSourceImageStatus && isAccelerated() && canvas()->buffer())
         canvas()->buffer()->flush();
 
     if (canvas()->originClean() && wouldTaintOrigin(imageSource))
         canvas()->setOriginTainted();
 }
 
 void CanvasRenderingContext2D::clearCanvas()
 {
     FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height());
     SkCanvas* c = drawingCanvas();
     if (!c)
         return;
 
-    c->clear(m_hasAlpha ? SK_ColorTRANSPARENT : SK_ColorBLACK);
+    checkOverdraw(canvasRect, 0, NoImage, ClipFill);
+    // Must not use 'c' beyond this point in case checkOverdraw substitutes the recording
+    // canvas in order to clear a draw command backlog.
+    drawingCanvas()->clear(m_hasAlpha ? SK_ColorTRANSPARENT : SK_ColorBLACK);
 }
 
 bool CanvasRenderingContext2D::rectContainsTransformedRect(const FloatRect& rect, const FloatRect& transformedRect) const
 {
     FloatQuad quad(rect);
     FloatQuad transformedQuad(transformedRect);
     return state().m_transform.mapQuad(quad).containsQuad(transformedQuad);
 }
 
 void CanvasRenderingContext2D::fullCanvasCompositedDraw(PassOwnPtr<Closure> draw)
@@ skipping 219 matching lines @@
     clipRect.intersect(IntRect(0, 0, data->width(), data->height()));
     IntSize destOffset(static_cast<int>(dx), static_cast<int>(dy));
     IntRect destRect = enclosingIntRect(clipRect);
     destRect.move(destOffset);
     destRect.intersect(IntRect(IntPoint(), buffer->size()));
     if (destRect.isEmpty())
         return;
     IntRect sourceRect(destRect);
     sourceRect.move(-destOffset);
 
+    checkOverdraw(destRect, 0, NoImage, UntransformedUnclippedFill);
+
     buffer->putByteArray(Unmultiplied, data->data()->data(), IntSize(data->width(), data->height()), sourceRect, IntPoint(destOffset));
 
     didDraw(destRect);
 }
 
 String CanvasRenderingContext2D::font() const
 {
     if (!state().m_realizedFont)
         return defaultFont;
 
@@ skipping 326 matching lines @@
     TextRunPaintInfo textRunPaintInfo(textRun);
     textRunPaintInfo.bounds = FloatRect(location.x() - fontMetrics.height() / 2,
                                         location.y() - fontMetrics.ascent() - fontMetrics.lineGap(),
                                         width + fontMetrics.height(),
                                         fontMetrics.lineSpacing());
     if (!fill)
         inflateStrokeRect(textRunPaintInfo.bounds);
 
     c->setTextDrawingMode(fill ? TextModeFill : TextModeStroke);
 
-    GraphicsContextStateSaver stateSaver(*c);
+    CanvasRenderingContext2DAutoRestoreSkCanvas stateRestorer(this);
     if (useMaxWidth) {
-        c->translate(location.x(), location.y());
+        SkCanvas* canvas = drawingCanvas();
+        canvas->save();
+        canvas->translate(location.x(), location.y());
         // We draw when fontWidth is 0 so compositing operations (eg, a "copy" op) still work.
-        c->scale((fontWidth > 0 ? (width / fontWidth) : 0), 1);
+        canvas->scale((fontWidth > 0 ? (width / fontWidth) : 0), 1);
         location = FloatPoint();
     }
 
     FloatRect clipBounds;
     if (!c->getTransformedClipBounds(&clipBounds)) {
         return;
     }
 
     if (isFullCanvasCompositeMode(state().m_globalComposite)) {
         fullCanvasCompositedDraw(bind(&GraphicsContext::drawBidiText, c, font, textRunPaintInfo, location, Font::UseFallbackIfFontNotReady));
@@ skipping 220 matching lines @@
 }
 
 unsigned CanvasRenderingContext2D::hitRegionsCount() const
 {
     if (m_hitRegionManager)
         return m_hitRegionManager->getHitRegionsCount();
 
     return 0;
 }
 
+void CanvasRenderingContext2D::checkOverdraw(const SkRect& rect, const SkPaint* paint, ImageType imageType, DrawType drawType)
+{
+    SkCanvas* c = drawingCanvas();
+    if (!c || !canvas()->buffer()->isRecording())
+        return;
+
+    SkRect deviceRect;
+    if (drawType == UntransformedUnclippedFill) {
+        deviceRect = rect;
+    } else {
+        ASSERT(drawType == ClipFill);
+        if (state().m_hasComplexClip)
+            return;
+
+        SkIRect skIBounds;
+        if (!c->getClipDeviceBounds(&skIBounds))
+            return;
+        deviceRect = SkRect::Make(skIBounds);
+    }
+
+    const SkImageInfo& imageInfo = c->imageInfo();
+    if (!deviceRect.contains(SkRect::MakeWH(imageInfo.width(), imageInfo.height())))
+        return;
+
+    bool isSourceOver = true;
+    unsigned alpha = 0xFF;
+    if (paint) {
+        if (paint->getLooper() || paint->getImageFilter() || paint->getMaskFilter())
+            return;
+
+        SkXfermode* xfermode = paint->getXfermode();
+        if (xfermode) {
+            SkXfermode::Mode mode;
+            if (xfermode->asMode(&mode)) {
+                isSourceOver = mode == SkXfermode::kSrcOver_Mode;
+                if (!isSourceOver && mode != SkXfermode::kSrc_Mode && mode != SkXfermode::kClear_Mode)
+                    return; // The code below only knows how to handle Src, SrcOver, and Clear
+            } else {
+                // unknown xfermode
+                ASSERT_NOT_REACHED();
+                return;
+            }
+        }
+
+        alpha = paint->getAlpha();
+
+        if (isSourceOver && imageType == NoImage) {
+            SkShader* shader = paint->getShader();
+            if (shader) {
+                if (shader->isOpaque() && alpha == 0xFF)
+                    canvas()->buffer()->willOverwriteCanvas();
+                return;
+            }
+        }
+    }
+
+    if (isSourceOver) {
+        // With source over, we need to certify that alpha == 0xFF for all pixels
+        if (imageType == NonOpaqueImage)
+            return;
+        if (alpha < 0xFF)
+            return;
+    }
+
+    canvas()->buffer()->willOverwriteCanvas();
+}
+
 } // namespace blink