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(DrawVectorImage, nullptr, dstRect.width(), dstRect.height());
+    } else {
+        trackDrawCall(DrawBitmapImage, 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 551 matching lines @@
         // With source over, we need to certify that alpha == 0xFF for all pixels
         if (imageType == CanvasRenderingContext2DState::NonOpaqueImage)
             return;
         if (alpha < 0xFF)
             return;
     }
 
     imageBuffer()->willOverwriteCanvas();
 }
 
 void BaseRenderingContext2D::trackDrawCall(DrawCallType callType, Path2D* path2d, int width, int height)

[Justin Novosad, 2016/08/04 17:28:15]

To minimize side-effects, could you make this function exit immediately when
dynamic switching is disabled?

[sebastienlc, 2016/08/04 20:20:17]

Done.

 {
     m_usageCounters.numDrawCalls[callType]++;
 
-    double boundingRectWidth = static_cast<double>(width);
-    double boundingRectHeight = static_cast<double>(height);
-    double boundingRectArea = boundingRectWidth * boundingRectHeight;
-    double boundingRectPerimeter = (2.0 * boundingRectWidth) + (2.0 * boundingRectHeight);
+    float boundingRectWidth = static_cast<float>(width);
+    float boundingRectHeight = static_cast<float>(height);
+    float boundingRectArea = boundingRectWidth * boundingRectHeight;
+    float 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 == DrawVectorImage || callType == DrawBitmapImage)) {
+            // The correct width and height were not passed as parameters
+            const SkRect& boundingRect = skPath.getBounds();
+            boundingRectWidth = static_cast<float>(std::abs(boundingRect.width()));
+            boundingRectHeight = static_cast<float>(std::abs(boundingRect.height()));
+            boundingRectArea = boundingRectWidth * boundingRectHeight;
+            boundingRectPerimeter = 2.0 * boundingRectWidth + 2.0 * boundingRectHeight;
         }
 
-        if (!(callType == FillRect || callType == StrokeRect || callType == DrawImage)) {
-            // 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) {
+            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 == DrawVectorImage || callType == DrawBitmapImage) {
+        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 == DrawVectorImage
+        || callType == DrawBitmapImage) {
         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},
-    boundingBoxAreaFillType {0.0, 0.0, 0.0, 0.0},
+    numDrawCalls {0, 0, 0, 0, 0, 0, 0},
+    boundingBoxPerimeterDrawCalls {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f},
+    boundingBoxAreaDrawCalls {0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f},
+    boundingBoxAreaFillType {0.0f, 0.0f, 0.0f, 0.0f},
     numNonConvexFillPathCalls(0),
-    numGradients(0),
+    nonConvexFillPathArea(0.0f),
+    numRadialGradients(0),
+    numLinearGradients(0),
     numPatterns(0),
     numDrawWithComplexClips(0),
     numBlurredShadows(0),
-    boundingBoxAreaTimesShadowBlurSquared(0.0),
-    boundingBoxPerimeterTimesShadowBlurSquared(0.0),
+    boundingBoxAreaTimesShadowBlurSquared(0.0f),
+    boundingBoxPerimeterTimesShadowBlurSquared(0.0f),
     numFilters(0),
     numGetImageDataCalls(0),
     areaGetImageDataCalls(0.0),
     numPutImageDataCalls(0),
     areaPutImageDataCalls(0.0),
     numClearRectCalls(0),
     numDrawFocusCalls(0),
     numFramesSinceReset(0) {}
 
+
+float BaseRenderingContext2D::estimateRenderingCost(ExpensiveCanvasHeuristicParameters::RenderingModeCostIndex index) const
+{
+    float basicCostOfDrawCalls =
+        ExpensiveCanvasHeuristicParameters::FillRectFixedCost[index] * m_usageCounters.numDrawCalls[BaseRenderingContext2D::FillRect] +
+        ExpensiveCanvasHeuristicParameters::FillConvexPathFixedCost[index] * (m_usageCounters.numDrawCalls[BaseRenderingContext2D::FillPath] - m_usageCounters.numNonConvexFillPathCalls) +
+        ExpensiveCanvasHeuristicParameters::FillNonConvexPathFixedCost[index] * m_usageCounters.numNonConvexFillPathCalls +
+        ExpensiveCanvasHeuristicParameters::FillTextFixedCost[index] * m_usageCounters.numDrawCalls[BaseRenderingContext2D::FillText] +
+
+        ExpensiveCanvasHeuristicParameters::StrokeRectFixedCost[index] * m_usageCounters.numDrawCalls[BaseRenderingContext2D::StrokeRect] +
+        ExpensiveCanvasHeuristicParameters::StrokePathFixedCost[index] * m_usageCounters.numDrawCalls[BaseRenderingContext2D::StrokePath] +
+        ExpensiveCanvasHeuristicParameters::StrokeTextFixedCost[index] * m_usageCounters.numDrawCalls[BaseRenderingContext2D::StrokeText] +
+
+        ExpensiveCanvasHeuristicParameters::FillRectVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::FillRect] +
+        ExpensiveCanvasHeuristicParameters::FillConvexPathVariableCostPerArea[index] * (m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::FillPath] - m_usageCounters.nonConvexFillPathArea) +
+        ExpensiveCanvasHeuristicParameters::FillNonConvexPathVariableCostPerArea[index] * m_usageCounters.nonConvexFillPathArea +
+        ExpensiveCanvasHeuristicParameters::FillTextVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::FillText] +
+
+        ExpensiveCanvasHeuristicParameters::StrokeRectVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::StrokeRect] +
+        ExpensiveCanvasHeuristicParameters::StrokePathVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::StrokePath] +
+        ExpensiveCanvasHeuristicParameters::StrokeTextVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::StrokeText] +
+
+        ExpensiveCanvasHeuristicParameters::PutImageDataFixedCost[index] * m_usageCounters.numPutImageDataCalls +
+        ExpensiveCanvasHeuristicParameters::PutImageDataVariableCostPerArea[index] * m_usageCounters.areaPutImageDataCalls +
+
+        ExpensiveCanvasHeuristicParameters::DrawSVGImageFixedCost[index] * m_usageCounters.numDrawCalls[BaseRenderingContext2D::DrawVectorImage] +
+        ExpensiveCanvasHeuristicParameters::DrawPNGImageFixedCost[index] * m_usageCounters.numDrawCalls[BaseRenderingContext2D::DrawBitmapImage] +
+
+        ExpensiveCanvasHeuristicParameters::DrawSVGImageVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::DrawVectorImage] +
+        ExpensiveCanvasHeuristicParameters::DrawPNGImageVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaDrawCalls[BaseRenderingContext2D::DrawBitmapImage];
+
+    float fillTypeAdjustment =
+        ExpensiveCanvasHeuristicParameters::PatternFillTypeFixedCost[index] * m_usageCounters.numPatterns +
+        ExpensiveCanvasHeuristicParameters::LinearGradientFillTypeFixedCost[index] * m_usageCounters.numLinearGradients +
+        ExpensiveCanvasHeuristicParameters::RadialGradientFillTypeFixedCost[index] * m_usageCounters.numRadialGradients +
+
+        ExpensiveCanvasHeuristicParameters::PatternFillTypeVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaFillType[BaseRenderingContext2D::PatternFillType] +
+        ExpensiveCanvasHeuristicParameters::LinearGradientFillVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaFillType[BaseRenderingContext2D::LinearGradientFillType] +
+        ExpensiveCanvasHeuristicParameters::RadialGradientFillVariableCostPerArea[index] * m_usageCounters.boundingBoxAreaFillType[BaseRenderingContext2D::RadialGradientFillType];
+
+    float shadowAdjustment =
+        ExpensiveCanvasHeuristicParameters::ShadowFixedCost[index] * m_usageCounters.numBlurredShadows +
+        ExpensiveCanvasHeuristicParameters::ShadowVariableCostPerAreaTimesShadowBlurSquared[index] * m_usageCounters.boundingBoxAreaTimesShadowBlurSquared;
+
+    return basicCostOfDrawCalls + fillTypeAdjustment + shadowAdjustment;
+}
+
 } // namespace blink