Improved heuristic for disable acceleration.

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

Index: third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp
diff --git a/third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp b/third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp
index f85fa19e099fb93512ea3ba4641da01ac768635c..8f80b02040daa0f04f29f6c585c61e1dd5c5e908 100644
--- a/third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp
+++ b/third_party/WebKit/Source/modules/canvas2d/BaseRenderingContext2D.cpp
@@ -949,7 +949,12 @@ static bool isDrawScalingDown(const FloatRect& srcRect, const FloatRect& dstRect
 
 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;
@@ -1523,12 +1528,17 @@ void BaseRenderingContext2D::checkOverdraw(const SkRect& rect, const SkPaint* pa
 
 void BaseRenderingContext2D::trackDrawCall(DrawCallType callType, Path2D* path2d, int width, int height)
 {
+    if (!RuntimeEnabledFeatures::enableCanvas2dDynamicRenderingModeSwitchingEnabled()) {
+        // Rendering mode switching is disabled so no need to track the usage
+        return;
+    }
+
     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
@@ -1544,19 +1554,21 @@ void BaseRenderingContext2D::trackDrawCall(DrawCallType callType, Path2D* path2d
             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 == DrawVectorImage || callType == DrawBitmapImage)) {
             // 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()));
+            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 == FillPath && skPath.getConvexity() != SkPath::kConvex_Convexity) {
+            m_usageCounters.numNonConvexFillPathCalls++;
+            m_usageCounters.nonConvexFillPathArea += boundingRectArea;
+        }
+
         m_usageCounters.boundingBoxPerimeterDrawCalls[callType] += boundingRectPerimeter;
         m_usageCounters.boundingBoxAreaDrawCalls[callType] += boundingRectArea;
 
@@ -1569,10 +1581,12 @@ void BaseRenderingContext2D::trackDrawCall(DrawCallType callType, Path2D* path2d
 
         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()) {
@@ -1583,9 +1597,9 @@ void BaseRenderingContext2D::trackDrawCall(DrawCallType callType, Path2D* path2d
         }
     }
 
-    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
@@ -1594,7 +1608,8 @@ void BaseRenderingContext2D::trackDrawCall(DrawCallType callType, Path2D* path2d
         || 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();
@@ -1622,17 +1637,19 @@ DEFINE_TRACE(BaseRenderingContext2D)
 }
 
 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),
@@ -1642,4 +1659,51 @@ BaseRenderingContext2D::UsageCounters::UsageCounters() :
     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