Allow RecordingImageBufferSurface to prevent fallback.

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"
@@ skipping 500 matching lines @@
   TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("copy")),
                   fillRect(0, 0, 5, 5));
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-over")),
                   fillRect(0, 0, 5, 5));
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-in")),
                   fillRect(0, 0, 5, 5));
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionByDefault) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), kNonOpaque);
+  auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
+      IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderOverdrawLimit) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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++) {
     Context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverOverdrawLimit) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
+  auto surface =
       WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), kNonOpaque);

[Justin Novosad, 2017/04/26 14:25:25]

Missed this guy.

   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;
        i++) {
     Context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderImageSizeRatioLimit) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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(
@@ skipping 12 matching lines @@
   Context2d()->drawImage(GetScriptState(), source_image_bitmap, 0, 0, 1, 1, 0,
                          0, 1, 1, exception_state);
   EXPECT_FALSE(exception_state.HadException());
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverImageSizeRatioLimit) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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(
@@ skipping 14 matching lines @@
                          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);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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;
        i++) {
     float angle_rad =
         twoPiFloat * i /
         (ExpensiveCanvasHeuristicParameters::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);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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;
        i++) {
     float angle_rad =
         twoPiFloat * i /
         (ExpensiveCanvasHeuristicParameters::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);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithRectangleClip) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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()->rect(1, 1, 2, 2);
   Context2d()->clip();
   Context2d()->fillRect(0, 0, 4, 4);
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithComplexClip) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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()->clip();
   Context2d()->fillRect(0, 0, 4, 4);
 
   if (ExpensiveCanvasHeuristicParameters::kComplexClipsAreExpensive) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithBlurredShadow) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithSharpShadow) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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()->setShadowOffsetX(1.0f);
   Context2d()->fillRect(1, 1, 1, 1);
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoFallbackWithSmallState) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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) {
     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);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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;
        ++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) {
   // Verify that drawing text to an opaque canvas, which is expected to
   // render with subpixel text anti-aliasing, results in falling out
   // of display list mode because the current diplay list implementation
   // does not support pixel geometry settings.
   // See: crbug.com/583809
   CreateContext(kOpaque);
-  auto surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), kOpaque);
+  auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
+      IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillText("Text", 0, 5);
 
   EXPECT_FALSE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        NonOpaqueDisplayListDoesNotFallBackForText) {
   CreateContext(kNonOpaque);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), kNonOpaque);
+  auto surface = WTF::MakeUnique<RecordingImageBufferSurface>(
+      IntSize(10, 10), RecordingImageBufferSurface::kAllowFallback, kNonOpaque);
   auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillText("Text", 0, 5);
 
   EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, ImageResourceLifetime) {
   NonThrowableExceptionState non_throwable_exception_state;
@@ skipping 563 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