Removing canvas rendering mode switching feature

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

 // Copyright 2014 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/CanvasRenderingContext2D.h"
 
 #include <memory>
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/Document.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLCanvasElement.h"
 #include "core/html/ImageData.h"
 #include "core/imagebitmap/ImageBitmapOptions.h"
 #include "core/layout/LayoutBoxModelObject.h"
 #include "core/loader/EmptyClients.h"
 #include "core/paint/PaintLayer.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
 #include "modules/webgl/WebGLRenderingContext.h"
 #include "platform/graphics/Canvas2DImageBufferSurface.h"
-#include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
+#include "platform/graphics/CanvasHeuristicParameters.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
 #include "platform/graphics/test/FakeGLES2Interface.h"
 #include "platform/graphics/test/FakeWebGraphicsContext3DProvider.h"
 #include "platform/loader/fetch/MemoryCache.h"
 #include "platform/testing/TestingPlatformSupport.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/scheduler/test/renderer_scheduler_test_support.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 494 matching lines @@
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderOverdrawLimit) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->setGlobalAlpha(0.5f);  // To prevent overdraw optimization
   for (int i = 0;
-       i < ExpensiveCanvasHeuristicParameters::kExpensiveOverdrawThreshold - 1;
-       i++) {
+       i < CanvasHeuristicParameters::kExpensiveOverdrawThreshold - 1; i++) {
     Context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverOverdrawLimit) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->setGlobalAlpha(0.5f);  // To prevent overdraw optimization
-  for (int i = 0;
-       i < ExpensiveCanvasHeuristicParameters::kExpensiveOverdrawThreshold;
+  for (int i = 0; i < CanvasHeuristicParameters::kExpensiveOverdrawThreshold;
        i++) {
     Context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderImageSizeRatioLimit) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   NonThrowableExceptionState exception_state;
   Element* source_canvas_element =
       GetDocument().createElement("canvas", exception_state);
   EXPECT_FALSE(exception_state.HadException());
   HTMLCanvasElement* source_canvas =
       static_cast<HTMLCanvasElement*>(source_canvas_element);
-  IntSize source_size(
-      10, 10 * ExpensiveCanvasHeuristicParameters::kExpensiveImageSizeRatio);
+  IntSize source_size(10,
+                      10 * CanvasHeuristicParameters::kExpensiveImageSizeRatio);
   std::unique_ptr<UnacceleratedImageBufferSurface> source_surface =
       WTF::MakeUnique<UnacceleratedImageBufferSurface>(source_size, kNonOpaque);
   source_canvas->CreateImageBufferUsingSurfaceForTesting(
       std::move(source_surface));
 
   const ImageBitmapOptions default_options;
   Optional<IntRect> crop_rect = IntRect(IntPoint(0, 0), source_size);
   // Go through an ImageBitmap to avoid triggering a display list fallback
   ImageBitmap* source_image_bitmap =
       ImageBitmap::Create(source_canvas, crop_rect, default_options);
@@ skipping 13 matching lines @@
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   NonThrowableExceptionState exception_state;
   Element* source_canvas_element =
       GetDocument().createElement("canvas", exception_state);
   EXPECT_FALSE(exception_state.HadException());
   HTMLCanvasElement* source_canvas =
       static_cast<HTMLCanvasElement*>(source_canvas_element);
   IntSize source_size(
-      10,
-      10 * ExpensiveCanvasHeuristicParameters::kExpensiveImageSizeRatio + 1);
+      10, 10 * CanvasHeuristicParameters::kExpensiveImageSizeRatio + 1);
   std::unique_ptr<UnacceleratedImageBufferSurface> source_surface =
       WTF::MakeUnique<UnacceleratedImageBufferSurface>(source_size, kNonOpaque);
   source_canvas->CreateImageBufferUsingSurfaceForTesting(
       std::move(source_surface));
 
   const ImageBitmapOptions default_options;
   Optional<IntRect> crop_rect = IntRect(IntPoint(0, 0), source_size);
   // Go through an ImageBitmap to avoid triggering a display list fallback
   ImageBitmap* source_image_bitmap =
       ImageBitmap::Create(source_canvas, crop_rect, default_options);
 
   Context2d()->drawImage(GetScriptState(), source_image_bitmap, 0, 0, 1, 1, 0,
                          0, 1, 1, exception_state);
   EXPECT_FALSE(exception_state.HadException());
 
   EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        NoLayerPromotionUnderExpensivePathPointCount) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->beginPath();
   Context2d()->moveTo(7, 5);
-  for (int i = 1;
-       i < ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount - 1;
+  for (int i = 1; i < CanvasHeuristicParameters::kExpensivePathPointCount - 1;
        i++) {
-    float angle_rad =
-        twoPiFloat * i /
-        (ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount - 1);
+    float angle_rad = twoPiFloat * i /
+                      (CanvasHeuristicParameters::kExpensivePathPointCount - 1);
     Context2d()->lineTo(5 + 2 * cos(angle_rad), 5 + 2 * sin(angle_rad));
   }
   Context2d()->fill();
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        LayerPromotionOverExpensivePathPointCount) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->beginPath();
   Context2d()->moveTo(7, 5);
-  for (int i = 1;
-       i < ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount + 1;
+  for (int i = 1; i < CanvasHeuristicParameters::kExpensivePathPointCount + 1;
        i++) {
-    float angle_rad =
-        twoPiFloat * i /
-        (ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount + 1);
+    float angle_rad = twoPiFloat * i /
+                      (CanvasHeuristicParameters::kExpensivePathPointCount + 1);
     Context2d()->lineTo(5 + 2 * cos(angle_rad), 5 + 2 * sin(angle_rad));
   }
   Context2d()->fill();
 
   EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWhenPathIsConcave) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->beginPath();
   Context2d()->moveTo(1, 1);
   Context2d()->lineTo(5, 5);
   Context2d()->lineTo(9, 1);
   Context2d()->lineTo(5, 9);
   Context2d()->fill();
 
-  if (ExpensiveCanvasHeuristicParameters::kConcavePathsAreExpensive) {
+  if (CanvasHeuristicParameters::kConcavePathsAreExpensive) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithRectangleClip) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
@@ skipping 18 matching lines @@
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->beginPath();
   Context2d()->moveTo(1, 1);
   Context2d()->lineTo(5, 5);
   Context2d()->lineTo(9, 1);
   Context2d()->lineTo(5, 9);
   Context2d()->clip();
   Context2d()->fillRect(0, 0, 4, 4);
 
-  if (ExpensiveCanvasHeuristicParameters::kComplexClipsAreExpensive) {
+  if (CanvasHeuristicParameters::kComplexClipsAreExpensive) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithBlurredShadow) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->setShadowColor(String("red"));
   Context2d()->setShadowBlur(1.0f);
   Context2d()->fillRect(1, 1, 1, 1);
 
-  if (ExpensiveCanvasHeuristicParameters::kBlurredShadowsAreExpensive) {
+  if (CanvasHeuristicParameters::kBlurredShadowsAreExpensive) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithSharpShadow) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
@@ skipping 11 matching lines @@
 
 TEST_F(CanvasRenderingContext2DTest, NoFallbackWithSmallState) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect.
   for (int i = 0;
-       i <
-       ExpensiveCanvasHeuristicParameters::kExpensiveRecordingStackDepth - 1;
-       ++i) {
+       i < CanvasHeuristicParameters::kExpensiveRecordingStackDepth - 1; ++i) {
     Context2d()->save();
     Context2d()->translate(1.0f, 0.0f);
   }
   CanvasElement().FinalizeFrame();  // To close the current frame.
 
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, FallbackWithLargeState) {
   CreateContext(kNonOpaque);
   auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
       IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect.
-  for (int i = 0;
-       i < ExpensiveCanvasHeuristicParameters::kExpensiveRecordingStackDepth;
+  for (int i = 0; i < CanvasHeuristicParameters::kExpensiveRecordingStackDepth;
        ++i) {
     Context2d()->save();
     Context2d()->translate(1.0f, 0.0f);
   }
   CanvasElement().FinalizeFrame();  // To close the current frame.
 
   EXPECT_FALSE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, OpaqueDisplayListFallsBackForText) {
@@ skipping 128 matching lines @@
   std::unique_ptr<Canvas2DImageBufferSurface> surface(
       new Canvas2DImageBufferSurface(bridge, size));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
   EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
   EXPECT_EQ(720000, GetGlobalGPUMemoryUsage());
 
   DummyExceptionStateForTesting exception_state;
   for (int i = 0;
-       i <
-       ExpensiveCanvasHeuristicParameters::kGPUReadbackMinSuccessiveFrames - 1;
+       i < CanvasHeuristicParameters::kGPUReadbackMinSuccessiveFrames - 1;
        i++) {
     Context2d()->getImageData(0, 0, 1, 1, exception_state);
     CanvasElement().FinalizeFrame();
 
     EXPECT_FALSE(exception_state.HadException());
     EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
     EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
     EXPECT_EQ(720000, GetGlobalGPUMemoryUsage());
   }
 
   Context2d()->getImageData(0, 0, 1, 1, exception_state);
   CanvasElement().FinalizeFrame();
 
   EXPECT_FALSE(exception_state.HadException());
-  if (ExpensiveCanvasHeuristicParameters::kGPUReadbackForcesNoAcceleration) {
+  if (CanvasHeuristicParameters::kGPUReadbackForcesNoAcceleration) {
     EXPECT_FALSE(CanvasElement().GetImageBuffer()->IsAccelerated());
     EXPECT_EQ(0u, GetGlobalAcceleratedImageBufferCount());
     EXPECT_EQ(0, GetGlobalGPUMemoryUsage());
   } else {
     EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
     EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
     EXPECT_EQ(720000, GetGlobalGPUMemoryUsage());
   }
 
   // Restore global state to prevent side-effects on other tests
   RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(
       saved_fixed_rendering_mode);
 }
 
 TEST_F(CanvasRenderingContext2DTest, TextureUploadHeuristics) {
   bool saved_fixed_rendering_mode =
       RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled();
   RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(false);
 
   enum TestVariants {
     kLargeTextureDisablesAcceleration = 0,
     kSmallTextureDoesNotDisableAcceleration = 1,
 
     kTestVariantCount = 2,
   };
 
   for (int test_variant = 0; test_variant < kTestVariantCount; test_variant++) {
     int delta = test_variant == kLargeTextureDisablesAcceleration ? 1 : -1;
-    int src_size = std::sqrt(static_cast<float>(
-                       ExpensiveCanvasHeuristicParameters::
-                           kDrawImageTextureUploadSoftSizeLimit)) +
-                   delta;
+    int src_size =
+        std::sqrt(static_cast<float>(
+            CanvasHeuristicParameters::kDrawImageTextureUploadSoftSizeLimit)) +
+        delta;
     int dst_size =
         src_size /
             std::sqrt(static_cast<float>(
-                ExpensiveCanvasHeuristicParameters::
+                CanvasHeuristicParameters::
                     kDrawImageTextureUploadSoftSizeLimitScaleThreshold)) -
         delta;
 
     CreateContext(kNonOpaque);
     FakeGLES2Interface gl;
     std::unique_ptr<FakeWebGraphicsContext3DProvider> context_provider(
         new FakeWebGraphicsContext3DProvider(&gl));
     IntSize size(dst_size, dst_size);
     RefPtr<Canvas2DLayerBridge> bridge =
         MakeBridge(std::move(context_provider), size,
@@ skipping 25 matching lines @@
       EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
       EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
       EXPECT_EQ(8 * dst_size * dst_size, GetGlobalGPUMemoryUsage());
     }
   }
   // Restore global state to prevent side-effects on other tests
   RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(
       saved_fixed_rendering_mode);
 }
 
-TEST_F(CanvasRenderingContext2DTest,
-       IsAccelerationOptimalForCanvasContentHeuristic) {
-  CreateContext(kNonOpaque);
-
-  auto fake_accelerate_surface =
-      WTF::MakeUnique<FakeAcceleratedImageBufferSurface>(IntSize(10, 10),
-                                                         kNonOpaque);
-  CanvasElement().CreateImageBufferUsingSurfaceForTesting(
-      std::move(fake_accelerate_surface));
-
-  NonThrowableExceptionState exception_state;
-
-  CanvasRenderingContext2D* context = Context2d();
-  EXPECT_TRUE(context->IsAccelerationOptimalForCanvasContent());
-
-  context->fillRect(10, 10, 100, 100);
-  EXPECT_TRUE(context->IsAccelerationOptimalForCanvasContent());
-
-  int num_reps = 100;
-  for (int i = 0; i < num_reps; i++) {
-    context->fillText("Text", 10, 10, 1);  // faster with no acceleration
-  }
-  EXPECT_FALSE(context->IsAccelerationOptimalForCanvasContent());
-
-  for (int i = 0; i < num_reps; i++) {
-    context->fillRect(10, 10, 200, 200);  // faster with acceleration
-  }
-  EXPECT_TRUE(context->IsAccelerationOptimalForCanvasContent());
-
-  for (int i = 0; i < num_reps * 100; i++) {
-    context->strokeText("Text", 10, 10, 1);  // faster with no acceleration
-  }
-  EXPECT_FALSE(context->IsAccelerationOptimalForCanvasContent());
-}
-
 TEST_F(CanvasRenderingContext2DTest, DisableAcceleration) {
   CreateContext(kNonOpaque);
 
   auto fake_accelerate_surface =
       WTF::MakeUnique<FakeAcceleratedImageBufferSurface>(IntSize(10, 10),
                                                          kNonOpaque);
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(
       std::move(fake_accelerate_surface));
   CanvasRenderingContext2D* context = Context2d();
 
@@ skipping 585 matching lines @@
 
   // Wake up again, which should request a compositing update synchronously.
   GetDocument().GetPage()->SetVisibilityState(kPageVisibilityStateVisible,
                                               false);
   EXPECT_EQ(!!CANVAS2D_HIBERNATION_ENABLED,
             layer->NeedsCompositingInputsUpdate());
   RunUntilIdle();  // Clear task queue.
 }
 
 }  // namespace blink