Removing canvas rendering mode switching feature

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 "core/css/cssom/CSSURLImageValue.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/dom/ArrayBufferViewHelpers.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLVideoElement.h"
 #include "core/html/ImageData.h"
 #include "core/offscreencanvas/OffscreenCanvas.h"
 #include "core/svg/SVGImageElement.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
 #include "modules/canvas2d/CanvasStyle.h"
 #include "modules/canvas2d/Path2D.h"
 #include "platform/Histogram.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/bindings/ScriptState.h"
 #include "platform/geometry/FloatQuad.h"
+#include "platform/graphics/CanvasHeuristicParameters.h"
 #include "platform/graphics/Color.h"
-#include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/StrokeData.h"
 #include "platform/graphics/paint/PaintCanvas.h"
 #include "platform/graphics/paint/PaintFlags.h"
 #include "platform/graphics/skia/SkiaUtils.h"
 #include "platform/wtf/CheckedNumeric.h"
 
 namespace blink {
 
@@ skipping 557 matching lines @@
 bool BaseRenderingContext2D::IsFullCanvasCompositeMode(SkBlendMode op) {
   // See 4.8.11.1.3 Compositing
   // CompositeSourceAtop and CompositeDestinationOut are not listed here as the
   // platforms already implement the specification's behavior.
   return op == SkBlendMode::kSrcIn || op == SkBlendMode::kSrcOut ||
          op == SkBlendMode::kDstIn || op == SkBlendMode::kDstATop;
 }
 
 static bool IsPathExpensive(const Path& path) {
   const SkPath& sk_path = path.GetSkPath();
-  if (ExpensiveCanvasHeuristicParameters::kConcavePathsAreExpensive &&
+  if (CanvasHeuristicParameters::kConcavePathsAreExpensive &&
       !sk_path.isConvex())
     return true;
 
   if (sk_path.countPoints() >
-      ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount)
+      CanvasHeuristicParameters::kExpensivePathPointCount)
     return true;
 
   return false;
 }
 
 void BaseRenderingContext2D::DrawPathInternal(
     const Path& path,
     CanvasRenderingContext2DState::PaintType paint_type,
     SkPath::FillType fill_type) {
   if (path.IsEmpty())
@@ skipping 26 matching lines @@
   if (winding_rule_string == "nonzero")
     return SkPath::kWinding_FillType;
   if (winding_rule_string == "evenodd")
     return SkPath::kEvenOdd_FillType;
 
   NOTREACHED();
   return SkPath::kEvenOdd_FillType;
 }
 
 void BaseRenderingContext2D::fill(const String& winding_rule_string) {
-  TrackDrawCall(kFillPath);
   DrawPathInternal(path_, CanvasRenderingContext2DState::kFillPaintType,
                    ParseWinding(winding_rule_string));
 }
 
 void BaseRenderingContext2D::fill(Path2D* dom_path,
                                   const String& winding_rule_string) {
-  TrackDrawCall(kFillPath, dom_path);
   DrawPathInternal(dom_path->GetPath(),
                    CanvasRenderingContext2DState::kFillPaintType,
                    ParseWinding(winding_rule_string));
 }
 
 void BaseRenderingContext2D::stroke() {
-  TrackDrawCall(kStrokePath);
   DrawPathInternal(path_, CanvasRenderingContext2DState::kStrokePaintType);
 }
 
 void BaseRenderingContext2D::stroke(Path2D* dom_path) {
-  TrackDrawCall(kStrokePath, dom_path);
   DrawPathInternal(dom_path->GetPath(),
                    CanvasRenderingContext2DState::kStrokePaintType);
 }
 
 void BaseRenderingContext2D::fillRect(double x,
                                       double y,
                                       double width,
                                       double height) {
-  TrackDrawCall(kFillRect, nullptr, width, height);
   if (!ValidateRectForCanvas(x, y, width, height))
     return;
 
   if (!DrawingCanvas())
     return;
 
   SkRect rect = SkRect::MakeXYWH(x, y, width, height);
   Draw([&rect](PaintCanvas* c, const PaintFlags* flags)  // draw lambda
        { c->drawRect(rect, *flags); },
        [&rect, this](const SkIRect& clip_bounds)  // overdraw test lambda
@@ skipping 14 matching lines @@
     canvas->drawPath(path, *flags);
     return;
   }
   canvas->drawRect(rect, *flags);
 }
 
 void BaseRenderingContext2D::strokeRect(double x,
                                         double y,
                                         double width,
                                         double height) {
-  TrackDrawCall(kStrokeRect, nullptr, width, height);
   if (!ValidateRectForCanvas(x, y, width, height))
     return;
 
   if (!DrawingCanvas())
     return;
 
   SkRect rect = SkRect::MakeXYWH(x, y, width, height);
   FloatRect bounds = rect;
   InflateStrokeRect(bounds);
   Draw([&rect](PaintCanvas* c, const PaintFlags* flags)  // draw lambda
@@ skipping 11 matching lines @@
   }
   if (!GetState().IsTransformInvertible()) {
     return;
   }
 
   SkPath sk_path = path.GetSkPath();
   sk_path.setFillType(ParseWinding(winding_rule_string));
   ModifiableState().ClipPath(sk_path, clip_antialiasing_);
   c->clipPath(sk_path, SkClipOp::kIntersect,
               clip_antialiasing_ == kAntiAliased);
-  if (ExpensiveCanvasHeuristicParameters::kComplexClipsAreExpensive &&
+  if (CanvasHeuristicParameters::kComplexClipsAreExpensive &&
       !sk_path.isRect(0) && HasImageBuffer()) {
     GetImageBuffer()->SetHasExpensiveOp();
   }
 }
 
 void BaseRenderingContext2D::clip(const String& winding_rule_string) {
   ClipInternal(path_, winding_rule_string);
 }
 
 void BaseRenderingContext2D::clip(Path2D* dom_path,
@@ skipping 279 matching lines @@
          dst_rect.Height() * dst_rect.Height() * y_scale_squared <
              src_rect.Height() * src_rect.Height();
 }
 
 void BaseRenderingContext2D::DrawImageInternal(PaintCanvas* c,
                                                CanvasImageSource* image_source,
                                                Image* image,
                                                const FloatRect& src_rect,
                                                const FloatRect& dst_rect,
                                                const PaintFlags* flags) {
-  if (image_source->IsSVGSource()) {
-    TrackDrawCall(kDrawVectorImage, nullptr, dst_rect.Width(),
-                  dst_rect.Height());
-  } else {
-    TrackDrawCall(kDrawBitmapImage, nullptr, dst_rect.Width(),
-                  dst_rect.Height());
-  }
-
   int initial_save_count = c->getSaveCount();
   PaintFlags image_flags = *flags;
 
   if (flags->getImageFilter()) {
     SkMatrix ctm = c->getTotalMatrix();
     SkMatrix inv_ctm;
     if (!ctm.invert(&inv_ctm)) {
       // 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 120 matching lines @@
     DisableDeferral(kDisableDeferralDrawImageWithTextureBackedSourceImage);
 
   ValidateStateStack();
 
   WillDrawImage(image_source);
 
   ValidateStateStack();
 
   // Heuristic for disabling acceleration based on anticipated texture upload
   // overhead.
-  // See comments in ExpensiveCanvasHeuristicParameters.h for explanation.
+  // See comments in CanvasHeuristicParameters.h for explanation.
   ImageBuffer* buffer = GetImageBuffer();
   if (buffer && buffer->IsAccelerated() && !image_source->IsAccelerated()) {
     float src_area = src_rect.Width() * src_rect.Height();
-    if (src_area > ExpensiveCanvasHeuristicParameters::
-                       kDrawImageTextureUploadHardSizeLimit) {
+    if (src_area >
+        CanvasHeuristicParameters::kDrawImageTextureUploadHardSizeLimit) {
       buffer->DisableAcceleration();
-    } else if (src_area > ExpensiveCanvasHeuristicParameters::
+    } else if (src_area > CanvasHeuristicParameters::
                               kDrawImageTextureUploadSoftSizeLimit) {
       SkRect bounds = dst_rect;
       SkMatrix ctm = DrawingCanvas()->getTotalMatrix();
       ctm.mapRect(&bounds);
       float dst_area = dst_rect.Width() * dst_rect.Height();
       if (src_area >
-          dst_area * ExpensiveCanvasHeuristicParameters::
+          dst_area * CanvasHeuristicParameters::
                          kDrawImageTextureUploadSoftSizeLimitScaleThreshold) {
         buffer->DisableAcceleration();
       }
     }
   }
 
   ValidateStateStack();
 
   // TODO(xidachen): After collecting some data, come back and prune off
   // the ones that is not needed.
@@ skipping 108 matching lines @@
       { return RectContainsTransformedRect(dst_rect, clip_bounds); },
       dst_rect, CanvasRenderingContext2DState::kImagePaintType,
       image_source->IsOpaque()
           ? CanvasRenderingContext2DState::kOpaqueImage
           : CanvasRenderingContext2DState::kNonOpaqueImage);
 
   ValidateStateStack();
 
   bool is_expensive = false;
 
-  if (ExpensiveCanvasHeuristicParameters::kSVGImageSourcesAreExpensive &&
+  if (CanvasHeuristicParameters::kSVGImageSourcesAreExpensive &&
       image_source->IsSVGSource())
     is_expensive = true;
 
   if (image_size.Width() * image_size.Height() >
-      Width() * Height() *
-          ExpensiveCanvasHeuristicParameters::kExpensiveImageSizeRatio)
+      Width() * Height() * CanvasHeuristicParameters::kExpensiveImageSizeRatio)
     is_expensive = true;
 
   if (is_expensive) {
     ImageBuffer* buffer = GetImageBuffer();
     if (buffer)
       buffer->SetHasExpensiveOp();
   }
 
   if (OriginClean() &&
       WouldTaintOrigin(image_source, ExecutionContext::From(script_state)))
@@ skipping 520 matching lines @@
     // With source over, we need to certify that alpha == 0xFF for all pixels
     if (image_type == CanvasRenderingContext2DState::kNonOpaqueImage)
       return;
     if (alpha < 0xFF)
       return;
   }
 
   GetImageBuffer()->WillOverwriteCanvas();
 }
 
-void BaseRenderingContext2D::TrackDrawCall(DrawCallType call_type,
-                                           Path2D* path2d,
-                                           int width,
-                                           int height) {
-  if (!RuntimeEnabledFeatures::
-          enableCanvas2dDynamicRenderingModeSwitchingEnabled()) {
-    // Rendering mode switching is disabled so no need to track the usage
-    return;
-  }
-
-  usage_counters_.num_draw_calls[call_type]++;
-
-  float bounding_rect_width = static_cast<float>(width);
-  float bounding_rect_height = static_cast<float>(height);
-  float bounding_rect_area = bounding_rect_width * bounding_rect_height;
-  float bounding_rect_perimeter =
-      (2.0 * bounding_rect_width) + (2.0 * bounding_rect_height);
-
-  if (call_type == kFillText || call_type == kFillPath ||
-      call_type == kStrokeText || call_type == kStrokePath ||
-      call_type == kFillRect || call_type == kStrokeRect) {
-    SkPath sk_path;
-    if (path2d) {
-      sk_path = path2d->GetPath().GetSkPath();
-    } else {
-      sk_path = path_.GetSkPath();
-    }
-
-    if (!(call_type == kFillRect || call_type == kStrokeRect ||
-          call_type == kDrawVectorImage || call_type == kDrawBitmapImage)) {
-      // The correct width and height were not passed as parameters
-      const SkRect& bounding_rect = sk_path.getBounds();
-      bounding_rect_width = static_cast<float>(std::abs(bounding_rect.width()));
-      bounding_rect_height =
-          static_cast<float>(std::abs(bounding_rect.height()));
-      bounding_rect_area = bounding_rect_width * bounding_rect_height;
-      bounding_rect_perimeter =
-          2.0 * bounding_rect_width + 2.0 * bounding_rect_height;
-    }
-
-    if (call_type == kFillPath &&
-        sk_path.getConvexity() != SkPath::kConvex_Convexity) {
-      usage_counters_.num_non_convex_fill_path_calls++;
-      usage_counters_.non_convex_fill_path_area += bounding_rect_area;
-    }
-
-    usage_counters_.bounding_box_perimeter_draw_calls[call_type] +=
-        bounding_rect_perimeter;
-    usage_counters_.bounding_box_area_draw_calls[call_type] +=
-        bounding_rect_area;
-
-    CanvasStyle* canvas_style;
-    if (call_type == kFillText || call_type == kFillPath ||
-        call_type == kFillRect) {
-      canvas_style = GetState().FillStyle();
-    } else {
-      canvas_style = GetState().StrokeStyle();
-    }
-
-    CanvasGradient* gradient = canvas_style->GetCanvasGradient();
-    if (gradient) {
-      switch (gradient->GetGradient()->GetType()) {
-        case Gradient::Type::kLinear:
-          usage_counters_.num_linear_gradients++;
-          usage_counters_.bounding_box_area_fill_type
-              [BaseRenderingContext2D::kLinearGradientFillType] +=
-              bounding_rect_area;
-          break;
-        case Gradient::Type::kRadial:
-          usage_counters_.num_radial_gradients++;
-          usage_counters_.bounding_box_area_fill_type
-              [BaseRenderingContext2D::kRadialGradientFillType] +=
-              bounding_rect_area;
-          break;
-        default:
-          NOTREACHED();
-      }
-    } else if (canvas_style->GetCanvasPattern()) {
-      usage_counters_.num_patterns++;
-      usage_counters_.bounding_box_area_fill_type
-          [BaseRenderingContext2D::kPatternFillType] += bounding_rect_area;
-    } else {
-      usage_counters_.bounding_box_area_fill_type
-          [BaseRenderingContext2D::kColorFillType] += bounding_rect_area;
-    }
-  }
-
-  if (call_type == kDrawVectorImage || call_type == kDrawBitmapImage) {
-    usage_counters_.bounding_box_perimeter_draw_calls[call_type] +=
-        bounding_rect_perimeter;
-    usage_counters_.bounding_box_area_draw_calls[call_type] +=
-        bounding_rect_area;
-  }
-
-  if (call_type == kFillText || call_type == kFillPath ||
-      call_type == kStrokeText || call_type == kStrokePath ||
-      call_type == kFillRect || call_type == kStrokeRect ||
-      call_type == kDrawVectorImage || call_type == kDrawBitmapImage) {
-    if (GetState().ShadowBlur() > 0.0 &&
-        SkColorGetA(GetState().ShadowColor()) > 0) {
-      usage_counters_.num_blurred_shadows++;
-      usage_counters_.bounding_box_area_times_shadow_blur_squared +=
-          bounding_rect_area * GetState().ShadowBlur() *
-          GetState().ShadowBlur();
-      usage_counters_.bounding_box_perimeter_times_shadow_blur_squared +=
-          bounding_rect_perimeter * GetState().ShadowBlur() *
-          GetState().ShadowBlur();
-    }
-  }
-
-  if (GetState().HasComplexClip()) {
-    usage_counters_.num_draw_with_complex_clips++;
-  }
-
-  if (StateHasFilter()) {
-    usage_counters_.num_filters++;
-  }
-}
-
 const BaseRenderingContext2D::UsageCounters&
 BaseRenderingContext2D::GetUsage() {
   return usage_counters_;
 }
 
 DEFINE_TRACE(BaseRenderingContext2D) {
   visitor->Trace(state_stack_);
 }
 
 BaseRenderingContext2D::UsageCounters::UsageCounters()
@@ skipping 13 matching lines @@
       bounding_box_perimeter_times_shadow_blur_squared(0.0f),
       num_filters(0),
       num_get_image_data_calls(0),
       area_get_image_data_calls(0.0),
       num_put_image_data_calls(0),
       area_put_image_data_calls(0.0),
       num_clear_rect_calls(0),
       num_draw_focus_calls(0),
       num_frames_since_reset(0) {}
 
-float BaseRenderingContext2D::EstimateRenderingCost(
-    ExpensiveCanvasHeuristicParameters::RenderingModeCostIndex index) const {
-  float basic_cost_of_draw_calls =
-      ExpensiveCanvasHeuristicParameters::kFillRectFixedCost[index] *
-          usage_counters_.num_draw_calls[BaseRenderingContext2D::kFillRect] +
-      ExpensiveCanvasHeuristicParameters::kFillConvexPathFixedCost[index] *
-          (usage_counters_.num_draw_calls[BaseRenderingContext2D::kFillPath] -
-           usage_counters_.num_non_convex_fill_path_calls) +
-      ExpensiveCanvasHeuristicParameters::kFillNonConvexPathFixedCost[index] *
-          usage_counters_.num_non_convex_fill_path_calls +
-      ExpensiveCanvasHeuristicParameters::kFillTextFixedCost[index] *
-          usage_counters_.num_draw_calls[BaseRenderingContext2D::kFillText] +
-
-      ExpensiveCanvasHeuristicParameters::kStrokeRectFixedCost[index] *
-          usage_counters_.num_draw_calls[BaseRenderingContext2D::kStrokeRect] +
-      ExpensiveCanvasHeuristicParameters::kStrokePathFixedCost[index] *
-          usage_counters_.num_draw_calls[BaseRenderingContext2D::kStrokePath] +
-      ExpensiveCanvasHeuristicParameters::kStrokeTextFixedCost[index] *
-          usage_counters_.num_draw_calls[BaseRenderingContext2D::kStrokeText] +
-
-      ExpensiveCanvasHeuristicParameters::kFillRectVariableCostPerArea[index] *
-          usage_counters_
-              .bounding_box_area_draw_calls[BaseRenderingContext2D::kFillRect] +
-      ExpensiveCanvasHeuristicParameters::kFillConvexPathVariableCostPerArea
-              [index] *
-          (usage_counters_.bounding_box_area_draw_calls
-               [BaseRenderingContext2D::kFillPath] -
-           usage_counters_.non_convex_fill_path_area) +
-      ExpensiveCanvasHeuristicParameters::kFillNonConvexPathVariableCostPerArea
-              [index] *
-          usage_counters_.non_convex_fill_path_area +
-      ExpensiveCanvasHeuristicParameters::kFillTextVariableCostPerArea[index] *
-          usage_counters_
-              .bounding_box_area_draw_calls[BaseRenderingContext2D::kFillText] +
-
-      ExpensiveCanvasHeuristicParameters::kStrokeRectVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_draw_calls
-              [BaseRenderingContext2D::kStrokeRect] +
-      ExpensiveCanvasHeuristicParameters::kStrokePathVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_draw_calls
-              [BaseRenderingContext2D::kStrokePath] +
-      ExpensiveCanvasHeuristicParameters::kStrokeTextVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_draw_calls
-              [BaseRenderingContext2D::kStrokeText] +
-
-      ExpensiveCanvasHeuristicParameters::kPutImageDataFixedCost[index] *
-          usage_counters_.num_put_image_data_calls +
-      ExpensiveCanvasHeuristicParameters::kPutImageDataVariableCostPerArea
-              [index] *
-          usage_counters_.area_put_image_data_calls +
-
-      ExpensiveCanvasHeuristicParameters::kDrawSVGImageFixedCost[index] *
-          usage_counters_
-              .num_draw_calls[BaseRenderingContext2D::kDrawVectorImage] +
-      ExpensiveCanvasHeuristicParameters::kDrawPNGImageFixedCost[index] *
-          usage_counters_
-              .num_draw_calls[BaseRenderingContext2D::kDrawBitmapImage] +
-
-      ExpensiveCanvasHeuristicParameters::kDrawSVGImageVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_draw_calls
-              [BaseRenderingContext2D::kDrawVectorImage] +
-      ExpensiveCanvasHeuristicParameters::kDrawPNGImageVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_draw_calls
-              [BaseRenderingContext2D::kDrawBitmapImage];
-
-  float fill_type_adjustment =
-      ExpensiveCanvasHeuristicParameters::kPatternFillTypeFixedCost[index] *
-          usage_counters_.num_patterns +
-      ExpensiveCanvasHeuristicParameters::kLinearGradientFillTypeFixedCost
-              [index] *
-          usage_counters_.num_linear_gradients +
-      ExpensiveCanvasHeuristicParameters::kRadialGradientFillTypeFixedCost
-              [index] *
-          usage_counters_.num_radial_gradients +
-
-      ExpensiveCanvasHeuristicParameters::kPatternFillTypeVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_fill_type
-              [BaseRenderingContext2D::kPatternFillType] +
-      ExpensiveCanvasHeuristicParameters::kLinearGradientFillVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_fill_type
-              [BaseRenderingContext2D::kLinearGradientFillType] +
-      ExpensiveCanvasHeuristicParameters::kRadialGradientFillVariableCostPerArea
-              [index] *
-          usage_counters_.bounding_box_area_fill_type
-              [BaseRenderingContext2D::kRadialGradientFillType];
-
-  float shadow_adjustment =
-      ExpensiveCanvasHeuristicParameters::kShadowFixedCost[index] *
-          usage_counters_.num_blurred_shadows +
-      ExpensiveCanvasHeuristicParameters::
-              kShadowVariableCostPerAreaTimesShadowBlurSquared[index] *
-          usage_counters_.bounding_box_area_times_shadow_blur_squared;
-
-  return basic_cost_of_draw_calls + fill_type_adjustment + shadow_adjustment;
-}
-
 }  // namespace blink