Remove unneeded abstractions and simplify RecordingImageBufferSurface

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/V8Binding.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/Document.h"
@@ skipping 241 matching lines @@
     std::unique_ptr<FakeWebGraphicsContext3DProvider> provider,
     const IntSize& size,
     Canvas2DLayerBridge::AccelerationMode acceleration_mode) {
   return AdoptRef(new Canvas2DLayerBridge(std::move(provider), size, 0,
                                           kNonOpaque, acceleration_mode,
                                           CanvasColorParams()));
 }
 
 //============================================================================
 
-class FakeAcceleratedImageBufferSurfaceForTesting
+class FakeAcceleratedImageBufferSurface
     : public UnacceleratedImageBufferSurface {
  public:
-  FakeAcceleratedImageBufferSurfaceForTesting(const IntSize& size,
-                                              OpacityMode mode)
+  FakeAcceleratedImageBufferSurface(const IntSize& size, OpacityMode mode)
       : UnacceleratedImageBufferSurface(size, mode), is_accelerated_(true) {}
-  ~FakeAcceleratedImageBufferSurfaceForTesting() override {}
+  ~FakeAcceleratedImageBufferSurface() override {}
   bool IsAccelerated() const override { return is_accelerated_; }
   void SetIsAccelerated(bool is_accelerated) {
     if (is_accelerated != is_accelerated_)
       is_accelerated_ = is_accelerated;
   }
 
  private:
   bool is_accelerated_;
 };
 
@@ skipping 10 matching lines @@
     return true;
   }  // otherwise overwrites are not tracked
 
   MOCK_METHOD0(WillOverwriteCanvas, void());
 };
 
 //============================================================================
 
 #define TEST_OVERDRAW_SETUP(EXPECTED_OVERDRAWS)                                \
   std::unique_ptr<MockImageBufferSurfaceForOverwriteTesting> mock_surface =    \
-      WTF::WrapUnique(new MockImageBufferSurfaceForOverwriteTesting(           \
-          IntSize(10, 10), kNonOpaque));                                       \
+      WTF::MakeUnique<MockImageBufferSurfaceForOverwriteTesting>(              \
+          IntSize(10, 10), kNonOpaque);                                        \
   MockImageBufferSurfaceForOverwriteTesting* surface_ptr = mock_surface.get(); \
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(                     \
       std::move(mock_surface));                                                \
   EXPECT_CALL(*surface_ptr, WillOverwriteCanvas()).Times(EXPECTED_OVERDRAWS);  \
   Context2d()->save();
 
 #define TEST_OVERDRAW_FINALIZE \
   Context2d()->restore();      \
   Mock::VerifyAndClearExpectations(surface_ptr);
 
@@ skipping 26 matching lines @@
     TEST_OVERDRAW_SETUP(EXPECTED_OVERDRAWS)                             \
     Context2d()->CALL1;                                                 \
     Context2d()->CALL2;                                                 \
     Context2d()->CALL3;                                                 \
     Context2d()->CALL4;                                                 \
     TEST_OVERDRAW_FINALIZE                                              \
   } while (0)
 
 //============================================================================
 
-class MockSurfaceFactory : public RecordingImageBufferFallbackSurfaceFactory {
- public:
-  enum FallbackExpectation { kExpectFallback, kExpectNoFallback };
-  static std::unique_ptr<MockSurfaceFactory> Create(
-      FallbackExpectation expectation) {
-    return WTF::WrapUnique(new MockSurfaceFactory(expectation));
-  }
-
-  std::unique_ptr<ImageBufferSurface> CreateSurface(
-      const IntSize& size,
-      OpacityMode mode,
-      const CanvasColorParams& color_params) override {
-    EXPECT_EQ(kExpectFallback, expectation_);
-    did_fallback_ = true;
-    return WTF::WrapUnique(new UnacceleratedImageBufferSurface(
-        size, mode, kInitializeImagePixels, color_params));
-  }
-
-  ~MockSurfaceFactory() override {
-    if (expectation_ == kExpectFallback) {
-      EXPECT_TRUE(did_fallback_);
-    }
-  }
-
- private:
-  MockSurfaceFactory(FallbackExpectation expectation)
-      : expectation_(expectation), did_fallback_(false) {}
-
-  FallbackExpectation expectation_;
-  bool did_fallback_;
-};
-
-//============================================================================
-
 TEST_F(CanvasRenderingContext2DTest, detectOverdrawWithFillRect) {
   CreateContext(kNonOpaque);
 
   TEST_OVERDRAW_1(1, fillRect(-1, -1, 12, 12));
   TEST_OVERDRAW_1(1, fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_1(
       0, strokeRect(0, 0, 10,
                     10));  // stroking instead of filling does not overwrite
   TEST_OVERDRAW_2(0, setGlobalAlpha(0.5f), fillRect(0, 0, 10, 10));
   TEST_OVERDRAW_1(0, fillRect(0, 0, 9, 9));
@@ skipping 156 matching lines @@
                   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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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 =
-      WTF::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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;
        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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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);
   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_FALSE(CanvasElement().ShouldBeDirectComposited());
+  EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverImageSizeRatioLimit) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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 + 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);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), kNonOpaque);
+  auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
-  Context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect
+  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
+  CanvasElement().FinalizeFrame();  // To close the current frame.
+
+  EXPECT_TRUE(surface_ptr->IsRecording());
 }
 
 TEST_F(CanvasRenderingContext2DTest, FallbackWithLargeState) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), kNonOpaque);
+  auto* surface_ptr = surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
-  Context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect
+  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
+  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);
-  std::unique_ptr<RecordingImageBufferSurface> surface =
-      WTF::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectFallback),
-          kOpaque));
+  auto surface =
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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::WrapUnique(new RecordingImageBufferSurface(
-          IntSize(10, 10),
-          MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque));
+      WTF::MakeUnique<RecordingImageBufferSurface>(IntSize(10, 10), 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;
   Element* canvas_element =
       GetDocument().createElement("canvas", non_throwable_exception_state);
   EXPECT_FALSE(non_throwable_exception_state.HadException());
   HTMLCanvasElement* canvas = static_cast<HTMLCanvasElement*>(canvas_element);
   canvas->SetSize(IntSize(40, 40));
   ImageBitmap* image_bitmap_derived = nullptr;
@@ skipping 12 matching lines @@
       canvas->GetCanvasRenderingContext("2d", attributes));
   DummyExceptionStateForTesting exception_state;
   CanvasImageSourceUnion image_source;
   image_source.setImageBitmap(image_bitmap_derived);
   context->drawImage(GetScriptState(), image_source, 0, 0, exception_state);
 }
 
 TEST_F(CanvasRenderingContext2DTest, GPUMemoryUpdateForAcceleratedCanvas) {
   CreateContext(kNonOpaque);
 
-  std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
-      fake_accelerate_surface =
-          WTF::WrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
-              IntSize(10, 10), kNonOpaque));
-  FakeAcceleratedImageBufferSurfaceForTesting* fake_accelerate_surface_ptr =
+  std::unique_ptr<FakeAcceleratedImageBufferSurface> fake_accelerate_surface =
+      WTF::MakeUnique<FakeAcceleratedImageBufferSurface>(IntSize(10, 10),
+                                                         kNonOpaque);
+  FakeAcceleratedImageBufferSurface* fake_accelerate_surface_ptr =
       fake_accelerate_surface.get();
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(
       std::move(fake_accelerate_surface));
   // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per
   // pixel per buffer, and 2 is an estimate of num of gpu buffers required
   EXPECT_EQ(800, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(800, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
 
   // Switching accelerated mode to non-accelerated mode
   fake_accelerate_surface_ptr->SetIsAccelerated(false);
   CanvasElement().Buffer()->UpdateGPUMemoryUsage();
   EXPECT_EQ(0, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(0, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(0u, GetGlobalAcceleratedImageBufferCount());
 
   // Switching non-accelerated mode to accelerated mode
   fake_accelerate_surface_ptr->SetIsAccelerated(true);
   CanvasElement().Buffer()->UpdateGPUMemoryUsage();
   EXPECT_EQ(800, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(800, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
 
   // Creating a different accelerated image buffer
-  std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
-      fake_accelerate_surface2 =
-          WTF::WrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
-              IntSize(10, 5), kNonOpaque));
+  auto fake_accelerate_surface2 =
+      WTF::MakeUnique<FakeAcceleratedImageBufferSurface>(IntSize(10, 5),
+                                                         kNonOpaque);
   std::unique_ptr<ImageBuffer> image_buffer2 =
       ImageBuffer::Create(std::move(fake_accelerate_surface2));
   EXPECT_EQ(800, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(1200, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(2u, GetGlobalAcceleratedImageBufferCount());
 
   // Tear down the first image buffer that resides in current canvas element
   CanvasElement().SetSize(IntSize(20, 20));
   Mock::VerifyAndClearExpectations(fake_accelerate_surface_ptr);
   EXPECT_EQ(400, GetGlobalGPUMemoryUsage());
@@ skipping 143 matching lines @@
   }
   // Restore global state to prevent side-effects on other tests
   RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(
       saved_fixed_rendering_mode);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        IsAccelerationOptimalForCanvasContentHeuristic) {
   CreateContext(kNonOpaque);
 
-  std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
-      fake_accelerate_surface =
-          WTF::WrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
-              IntSize(10, 10), 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());
@@ skipping 11 matching lines @@
 
   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);
 
-  std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting>
-      fake_accelerate_surface =
-          WTF::WrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(
-              IntSize(10, 10), kNonOpaque));
+  auto fake_accelerate_surface =
+      WTF::MakeUnique<FakeAcceleratedImageBufferSurface>(IntSize(10, 10),
+                                                         kNonOpaque);
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(
       std::move(fake_accelerate_surface));
   CanvasRenderingContext2D* context = Context2d();
 
   // 800 = 10 * 10 * 4 * 2 where 10*10 is canvas size, 4 is num of bytes per
   // pixel per buffer, and 2 is an estimate of num of gpu buffers required
   EXPECT_EQ(800, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(800, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
 
@@ skipping 284 matching lines @@
   EXPECT_FALSE(layer->NeedsCompositingInputsUpdate());
 
   // Wake up again, which should request a compositing update synchronously.
   GetDocument().GetPage()->SetVisibilityState(kPageVisibilityStateVisible,
                                               false);
   EXPECT_EQ(!!CANVAS2D_HIBERNATION_ENABLED,
             layer->NeedsCompositingInputsUpdate());
 }
 
 }  // namespace blink