Cancel GPU acceleration for 2D canvas when drawing very large images

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 946 matching lines @@
 }
 
 void BaseRenderingContext2D::drawImageInternal(SkCanvas* c, CanvasImageSource* imageSource, Image* image, const FloatRect& srcRect, const FloatRect& dstRect, const SkPaint* paint)
 {
     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
             // for SkMatrix to find the transform to be non-invertible at this stage.
@@ skipping 91 matching lines @@
         return;
 
     DisableDeferralReason reason = DisableDeferralReasonUnknown;
     if (shouldDisableDeferral(imageSource, &reason))
         disableDeferral(reason);
     else if (image->isTextureBacked())
         disableDeferral(DisableDeferralDrawImageWithTextureBackedSourceImage);
 
     validateStateStack();
 
+    // Heuristic for disabling acceleration based on anticipated texture upload overhead
+    // See comments in ExpensiveCanvasHeuristicParameters.h for explanation.
+    ImageBuffer* buffer = imageBuffer();
+    if (buffer && buffer->isAccelerated() && !imageSource->isAccelerated()) {
+        float srcArea = srcRect.width() * srcRect.height();
+        if (srcArea > ExpensiveCanvasHeuristicParameters::DrawImageTextureUploadHardSizeLimit) {
+            buffer->disableAcceleration();
+        } else if (srcArea > ExpensiveCanvasHeuristicParameters::DrawImageTextureUploadSoftSizeLimit) {
+            SkRect bounds = dstRect;
+            SkMatrix ctm = drawingCanvas()->getTotalMatrix();
+            ctm.mapRect(&bounds);
+            float dstArea = dstRect.width() * dstRect.height();
+            if (srcArea > dstArea * ExpensiveCanvasHeuristicParameters::DrawImageTextureUploadSoftSizeLimitScaleThreshold) {

[xidachen, 2016/09/23 20:56:36]

I am a little confused by this logic.

Say that srcArea = 7M*7M, so it goes into this else if block. Assuming that
dstArea is the same, then this if statement is false, and we don't disable it?
So we disable acceleration either:
1). srcArea is very large
2). srcArea is large, and dstArea is small by factor of 4

I don't quite understand the second logic.

+                buffer->disableAcceleration();
+            }
+        }
+    }
+
+    validateStateStack();
+
     // TODO(xidachen): After collecting some data, come back and prune off
     // the ones that is not needed.
     Optional<ScopedUsHistogramTimer> timer;
     if (imageBuffer() && imageBuffer()->isAccelerated()) {
         if (imageSource->isVideoElement()) {
             DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterVideoGPU, new CustomCountHistogram("Blink.Canvas.DrawImage.Video.GPU", 0, 10000000, 50));
             timer.emplace(scopedUsCounterVideoGPU);
         } else if (imageSource->isCanvasElement()) {
             DEFINE_THREAD_SAFE_STATIC_LOCAL(CustomCountHistogram, scopedUsCounterCanvasGPU, new CustomCountHistogram("Blink.Canvas.DrawImage.Canvas.GPU", 0, 10000000, 50));
             timer.emplace(scopedUsCounterCanvasGPU);
@@ skipping 620 matching lines @@
         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