Add display list fallback reason histograms for 2D canvas

third_party/WebKit/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 420 matching lines @@
         }
         canvasStyle = CanvasStyle::createFromRGBA(parsedColor.rgb());
     } else if (style.isCanvasGradient()) {
         canvasStyle = CanvasStyle::createFromGradient(style.getAsCanvasGradient());
     } else if (style.isCanvasPattern()) {
         CanvasPattern* canvasPattern = style.getAsCanvasPattern();
 
         if (canvas()->originClean() && !canvasPattern->originClean())
             canvas()->setOriginTainted();
         if (canvasPattern->pattern()->isTextureBacked())
-            canvas()->disableDeferral();
+            canvas()->disableDeferral(DisableDeferralReasonUsingTextureBackedPattern);
         canvasStyle = CanvasStyle::createFromPattern(canvasPattern);
     }
 
     ASSERT(canvasStyle);
     modifiableState().setFillStyle(canvasStyle);
     modifiableState().setUnparsedFillColor(colorString);
 }
 
 double CanvasRenderingContext2D::lineWidth() const
 {
@@ skipping 882 matching lines @@
         c->translate(dstRect.x(), dstRect.y());
         c->scale(dstRect.width() / srcRect.width(), dstRect.height() / srcRect.height());
         c->translate(-srcRect.x(), -srcRect.y());
         HTMLVideoElement* video = static_cast<HTMLVideoElement*>(imageSource);
         video->paintCurrentFrame(c, IntRect(IntPoint(), IntSize(video->videoWidth(), video->videoHeight())), &imagePaint);
     }
 
     c->restoreToCount(initialSaveCount);
 }
 
-bool shouldDisableDeferral(CanvasImageSource* imageSource)
+bool shouldDisableDeferral(CanvasImageSource* imageSource, DisableDeferralReason* reason)
 {
-    if (imageSource->isVideoElement())
+    ASSERT(reason);
+    ASSERT(*reason == DisableDeferralReasonUnknown);
+
+    if (imageSource->isVideoElement()) {
+        *reason = DisableDeferralReasonDrawImageOfVideo;
         return true;
+    }
     if (imageSource->isCanvasElement()) {
         HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(imageSource);
-        if (canvas->isAnimated2D())
+        if (canvas->isAnimated2D()) {
+            *reason = DisableDeferralReasonDrawImageOfAnimated2dCanvas;
             return true;
+        }
     }
     return false;
 }
 
 void CanvasRenderingContext2D::drawImage(CanvasImageSource* imageSource,
     double sx, double sy, double sw, double sh,
     double dx, double dy, double dw, double dh, ExceptionState& exceptionState)
 {
     if (!drawingCanvas())
         return;
 
     RefPtr<Image> image;
     SourceImageStatus sourceImageStatus = InvalidSourceImageStatus;
     if (!imageSource->isVideoElement()) {
         AccelerationHint hint = canvas()->buffer()->isAccelerated() ? PreferAcceleration : PreferNoAcceleration;
-        image = imageSource->getSourceImageForCanvas(&sourceImageStatus, hint);
+        image = imageSource->getSourceImageForCanvas(&sourceImageStatus, hint, SnapshotReasonDrawImage);
         if (sourceImageStatus == UndecodableSourceImageStatus)
             exceptionState.throwDOMException(InvalidStateError, "The HTMLImageElement provided is in the 'broken' state.");
         if (!image || !image->width() || !image->height())
             return;
     } else {
         if (!static_cast<HTMLVideoElement*>(imageSource)->hasAvailableVideoFrame())
             return;
     }
 
     if (!std::isfinite(dx) || !std::isfinite(dy) || !std::isfinite(dw) || !std::isfinite(dh)
         || !std::isfinite(sx) || !std::isfinite(sy) || !std::isfinite(sw) || !std::isfinite(sh)
         || !dw || !dh || !sw || !sh)
         return;
 
     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;
 
-    if (shouldDisableDeferral(imageSource) || image->isTextureBacked())
-        canvas()->disableDeferral();
+    DisableDeferralReason reason = DisableDeferralReasonUnknown;
+    if (shouldDisableDeferral(imageSource, &reason) || image->isTextureBacked())
+        canvas()->disableDeferral(reason);
 
     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
         {
@@ skipping 13 matching lines @@
 
     if (isExpensive) {
         ImageBuffer* buffer = canvas()->buffer();
         if (buffer)
             buffer->setHasExpensiveOp();
     }
 
     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();
+        canvas()->buffer()->flushGpu(FlushReasonDrawImageOfWebGL);
     }
 
     if (canvas()->originClean() && wouldTaintOrigin(imageSource))
         canvas()->setOriginTainted();
 }
 
 void CanvasRenderingContext2D::clearCanvas()
 {
     FloatRect canvasRect(0, 0, canvas()->width(), canvas()->height());
     checkOverdraw(canvasRect, 0, CanvasRenderingContext2DState::NoImage, ClipFill);
@@ skipping 27 matching lines @@
 }
 
 CanvasPattern* CanvasRenderingContext2D::createPattern(const CanvasImageSourceUnion& imageSource, const String& repetitionType, ExceptionState& exceptionState)
 {
     Pattern::RepeatMode repeatMode = CanvasPattern::parseRepetitionType(repetitionType, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     SourceImageStatus status;
     CanvasImageSource* imageSourceInternal = toImageSourceInternal(imageSource);
-    RefPtr<Image> imageForRendering = imageSourceInternal->getSourceImageForCanvas(&status, PreferNoAcceleration);
+    RefPtr<Image> imageForRendering = imageSourceInternal->getSourceImageForCanvas(&status, PreferNoAcceleration, SnapshotReasonCreatePattern);
 
     switch (status) {
     case NormalSourceImageStatus:
         break;
     case ZeroSizeCanvasSourceImageStatus:
         exceptionState.throwDOMException(InvalidStateError, String::format("The canvas %s is 0.", imageSourceInternal->elementSize().width() ? "height" : "width"));
         return nullptr;
     case UndecodableSourceImageStatus:
         exceptionState.throwDOMException(InvalidStateError, "Source image is in the 'broken' state.");
         return nullptr;
@@ skipping 467 matching lines @@
     if (!std::isfinite(x) || !std::isfinite(y))
         return;
     if (maxWidth && (!std::isfinite(*maxWidth) || *maxWidth <= 0))
         return;
 
     // Currently, SkPictureImageFilter does not support subpixel text anti-aliasing, which
     // is expected when !m_hasAlpha, so we need to fall out of display list mode when
     // drawing text to an opaque canvas
     // crbug.com/583809
     if (!m_hasAlpha && !isAccelerated())
-        canvas()->disableDeferral();
+        canvas()->disableDeferral(DisableDeferralReasonSubPixelTextAntiAliasingSupport);
 
     const Font& font = accessFont();
     const FontMetrics& fontMetrics = font.fontMetrics();
 
     // FIXME: Need to turn off font smoothing.
 
     const ComputedStyle* computedStyle = 0;
     TextDirection direction = toTextDirection(state().direction(), canvas(), &computedStyle);
     bool isRTL = direction == RTL;
     bool override = computedStyle ? isOverride(computedStyle->unicodeBidi()) : false;
@@ skipping 359 matching lines @@
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     canvas()->buffer()->willOverwriteCanvas();
 }
 
 } // namespace blink