Improved heuristic for disable acceleration.

third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp

 // Copyright 2016 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 "modules/canvas2d/BaseRenderingContext2D.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/css/parser/CSSParser.h"
@@ skipping 931 matching lines @@
 }
 
 static bool isDrawScalingDown(const FloatRect& srcRect, const FloatRect& dstRect, float xScaleSquared, float yScaleSquared)
 {
     return dstRect.width() * dstRect.width() * xScaleSquared < srcRect.width() * srcRect.width()
         && dstRect.height() * dstRect.height() * yScaleSquared < srcRect.height() * srcRect.height();
 }
 
 void BaseRenderingContext2D::drawImageInternal(SkCanvas* c, CanvasImageSource* imageSource, Image* image, const FloatRect& srcRect, const FloatRect& dstRect, const SkPaint* paint)
 {
-    trackDrawCall(DrawImage, nullptr, dstRect.width(), dstRect.height());
+    if (imageSource->isSVGSource()) {
+        trackDrawCall(DrawSVGImage, nullptr, dstRect.width(), dstRect.height());
+    } else {
+        trackDrawCall(DrawPNGImage, nullptr, dstRect.width(), dstRect.height());
+    }
+
 
     int initialSaveCount = c->getSaveCount();
     SkPaint imagePaint = *paint;
 
     if (paint->getImageFilter()) {
         SkMatrix ctm = c->getTotalMatrix();
         SkMatrix invCtm;
         if (!ctm.invert(&invCtm)) {
             // There is an earlier check for invertibility, but the arithmetic
             // in AffineTransform is not exactly identical, so it is possible
@@ skipping 555 matching lines @@
             return;
     }
 
     imageBuffer()->willOverwriteCanvas();
 }
 
 void BaseRenderingContext2D::trackDrawCall(DrawCallType callType, Path2D* path2d, int width, int height)
 {
     m_usageCounters.numDrawCalls[callType]++;
 
     double boundingRectWidth = static_cast<double>(width);

[Justin Novosad, 2016/08/04 15:53:16]

make these float

[sebastienlc, 2016/08/04 16:36:27]

Done.

     double boundingRectHeight = static_cast<double>(height);
     double boundingRectArea = boundingRectWidth * boundingRectHeight;
     double boundingRectPerimeter = (2.0 * boundingRectWidth) + (2.0 * boundingRectHeight);
 
     if (callType == FillText
         || callType == FillPath
         || callType == StrokeText
         || callType == StrokePath
         || callType == FillRect
         || callType == StrokeRect) {
 
         SkPath skPath;
         if (path2d) {
             skPath = path2d->path().getSkPath();
         } else {
             skPath = m_path.getSkPath();
         }
 
-        if (callType == FillPath && !(skPath.getConvexity() == SkPath::kConvex_Convexity)) {
-            m_usageCounters.numNonConvexFillPathCalls++;
-        }
 
-        if (!(callType == FillRect || callType == StrokeRect || callType == DrawImage)) {
+        if (!(callType == FillRect || callType == StrokeRect || callType == DrawSVGImage || callType == DrawPNGImage)) {
             // The correct width and height were not passed as parameters
             const SkRect& boundingRect = skPath.getBounds();
             boundingRectWidth = static_cast<double>(std::abs(boundingRect.width()));
             boundingRectHeight = static_cast<double>(std::abs(boundingRect.height()));
             boundingRectArea = boundingRectWidth * boundingRectHeight;
             boundingRectPerimeter = 2.0 * boundingRectWidth + 2.0 * boundingRectHeight;
         }
 
+        if (callType == FillPath && !(skPath.getConvexity() == SkPath::kConvex_Convexity)) {

[Justin Novosad, 2016/08/04 15:53:16]

!(a == b)    ->  a != b

[sebastienlc, 2016/08/04 16:36:27]

Done.

+            m_usageCounters.numNonConvexFillPathCalls++;
+            m_usageCounters.nonConvexFillPathArea += boundingRectArea;
+        }
+
         m_usageCounters.boundingBoxPerimeterDrawCalls[callType] += boundingRectPerimeter;
         m_usageCounters.boundingBoxAreaDrawCalls[callType] += boundingRectArea;
 
         CanvasStyle* canvasStyle;
         if (callType == FillText || callType == FillPath || callType == FillRect) {
             canvasStyle = state().fillStyle();
         } else {
             canvasStyle = state().strokeStyle();
         }
 
         CanvasGradient* gradient = canvasStyle->getCanvasGradient();
         if (gradient) {
-            m_usageCounters.numGradients++;
+
             if (gradient->getGradient()->isRadial()) {
+                m_usageCounters.numRadialGradients++;
                 m_usageCounters.boundingBoxAreaFillType[BaseRenderingContext2D::RadialGradientFillType] += boundingRectArea;
             } else {
+                m_usageCounters.numLinearGradients++;
                 m_usageCounters.boundingBoxAreaFillType[BaseRenderingContext2D::LinearGradientFillType] += boundingRectArea;
             }
         } else if (canvasStyle->getCanvasPattern()) {
             m_usageCounters.numPatterns++;
             m_usageCounters.boundingBoxAreaFillType[BaseRenderingContext2D::PatternFillType] += boundingRectArea;
         } else {
             m_usageCounters.boundingBoxAreaFillType[BaseRenderingContext2D::ColorFillType] += boundingRectArea;
         }
     }
 
-    if (callType == DrawImage) {
-        m_usageCounters.boundingBoxPerimeterDrawCalls[DrawImage] += boundingRectPerimeter;
-        m_usageCounters.boundingBoxAreaDrawCalls[DrawImage] += boundingRectArea;
+    if (callType == DrawSVGImage || callType == DrawPNGImage) {
+        m_usageCounters.boundingBoxPerimeterDrawCalls[callType] += boundingRectPerimeter;
+        m_usageCounters.boundingBoxAreaDrawCalls[callType] += boundingRectArea;
     }
 
     if (callType == FillText
         || callType == FillPath
         || callType == StrokeText
         || callType == StrokePath
         || callType == FillRect
         || callType == StrokeRect
-        || callType == DrawImage) {
+        || callType == DrawSVGImage
+        || callType == DrawPNGImage) {
         if (state().shadowBlur() > 0.0 && SkColorGetA(state().shadowColor()) > 0) {
             m_usageCounters.numBlurredShadows++;
             m_usageCounters.boundingBoxAreaTimesShadowBlurSquared += boundingRectArea * state().shadowBlur() * state().shadowBlur();
             m_usageCounters.boundingBoxPerimeterTimesShadowBlurSquared += boundingRectPerimeter * state().shadowBlur() * state().shadowBlur();
         }
     }
 
     if (state().hasComplexClip()) {
         m_usageCounters.numDrawWithComplexClips++;
     }
 
     if (stateHasFilter()) {
         m_usageCounters.numFilters++;
     }
 }
 
 const BaseRenderingContext2D::UsageCounters& BaseRenderingContext2D::getUsage()
 {
     return m_usageCounters;
 }
 
 DEFINE_TRACE(BaseRenderingContext2D)
 {
     visitor->trace(m_stateStack);
 }
 
 BaseRenderingContext2D::UsageCounters::UsageCounters() :
-    numDrawCalls {0, 0, 0, 0, 0, 0},
-    boundingBoxPerimeterDrawCalls {0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
-    boundingBoxAreaDrawCalls {0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
+    numDrawCalls {0, 0, 0, 0, 0, 0, 0},
+    boundingBoxPerimeterDrawCalls {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},

[Justin Novosad, 2016/08/04 15:53:16]

0.0   -> 0.0f  here and below

[sebastienlc, 2016/08/04 16:36:27]

Done.

+    boundingBoxAreaDrawCalls {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0},
     boundingBoxAreaFillType {0.0, 0.0, 0.0, 0.0},
     numNonConvexFillPathCalls(0),
-    numGradients(0),
+    nonConvexFillPathArea(0.0),
+    numRadialGradients(0),
+    numLinearGradients(0),
     numPatterns(0),
     numDrawWithComplexClips(0),
     numBlurredShadows(0),
     boundingBoxAreaTimesShadowBlurSquared(0.0),
     boundingBoxPerimeterTimesShadowBlurSquared(0.0),
     numFilters(0),
     numGetImageDataCalls(0),
     areaGetImageDataCalls(0.0),
     numPutImageDataCalls(0),
     areaPutImageDataCalls(0.0),
     numClearRectCalls(0),
     numDrawFocusCalls(0),
     numFramesSinceReset(0) {}
 
 } // namespace blink