Refactor ImageBuffer to make OffscreenCanvas match HTMLCanvasElement

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 43 matching lines @@
 
 enum BitmapOpacity { kOpaqueBitmap, kTransparentBitmap };
 
 class FakeImageSource : public CanvasImageSource {
  public:
   FakeImageSource(IntSize, BitmapOpacity);
 
   PassRefPtr<Image> GetSourceImageForCanvas(SourceImageStatus*,
                                             AccelerationHint,
                                             SnapshotReason,
-                                            const FloatSize&) const override;
+                                            const FloatSize&) override;
 
   bool WouldTaintOrigin(
       SecurityOrigin* destination_security_origin) const override {
     return false;
   }
   FloatSize ElementSize(const FloatSize&) const override {
     return FloatSize(size_);
   }
   bool IsOpaque() const override { return is_opaque_; }
   bool IsAccelerated() const { return false; }
@@ skipping 14 matching lines @@
       SkSurface::MakeRasterN32Premul(size_.Width(), size_.Height()));
   surface->getCanvas()->clear(opacity == kOpaqueBitmap ? SK_ColorWHITE
                                                        : SK_ColorTRANSPARENT);
   image_ = StaticBitmapImage::Create(surface->makeImageSnapshot());
 }
 
 PassRefPtr<Image> FakeImageSource::GetSourceImageForCanvas(
     SourceImageStatus* status,
     AccelerationHint,
     SnapshotReason,
-    const FloatSize&) const {
+    const FloatSize&) {
   if (status)
     *status = kNormalSourceImageStatus;
   return image_;
 }
 
 //============================================================================
 
 enum LinearPixelMathState { kLinearPixelMathDisabled, kLinearPixelMathEnabled };
 
 class CanvasRenderingContext2DTest : public ::testing::Test {
  protected:
   CanvasRenderingContext2DTest();
   void SetUp() override;
 
   DummyPageHolder& Page() const { return *dummy_page_holder_; }
   Document& GetDocument() const { return *document_; }
   HTMLCanvasElement& CanvasElement() const { return *canvas_element_; }
   CanvasRenderingContext2D* Context2d() const {
     return static_cast<CanvasRenderingContext2D*>(
         CanvasElement().RenderingContext());
   }
   intptr_t GetGlobalGPUMemoryUsage() const {
     return ImageBuffer::GetGlobalGPUMemoryUsage();
   }
   unsigned GetGlobalAcceleratedImageBufferCount() const {
     return ImageBuffer::GetGlobalAcceleratedImageBufferCount();
   }
   intptr_t GetCurrentGPUMemoryUsage() const {
-    return CanvasElement().Buffer()->GetGPUMemoryUsage();
+    return CanvasElement().GetImageBuffer()->GetGPUMemoryUsage();
   }
 
   void CreateContext(OpacityMode,
                      String color_space = String(),
                      LinearPixelMathState = kLinearPixelMathDisabled);
   ScriptState* GetScriptState() {
     return ToScriptStateForMainWorld(canvas_element_->GetFrame());
   }
 
   void TearDown();
@@ skipping 744 matching lines @@
   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();
+  CanvasElement().GetImageBuffer()->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();
+  CanvasElement().GetImageBuffer()->UpdateGPUMemoryUsage();
   EXPECT_EQ(800, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(800, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
 
   // Creating a different accelerated image buffer
   auto fake_accelerate_surface2 =
       WTF::MakeUnique<FakeAcceleratedImageBufferSurface>(IntSize(10, 5),
                                                          kNonOpaque);
   std::unique_ptr<ImageBuffer> image_buffer2 =
       ImageBuffer::Create(std::move(fake_accelerate_surface2));
@@ skipping 43 matching lines @@
   std::unique_ptr<FakeWebGraphicsContext3DProvider> context_provider(
       new FakeWebGraphicsContext3DProvider(&gl));
   IntSize size(300, 300);
   RefPtr<Canvas2DLayerBridge> bridge =
       MakeBridge(std::move(context_provider), size,
                  Canvas2DLayerBridge::kEnableAcceleration);
   std::unique_ptr<Canvas2DImageBufferSurface> surface(
       new Canvas2DImageBufferSurface(bridge, size));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
-  EXPECT_TRUE(CanvasElement().Buffer()->IsAccelerated());
+  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++) {
     Context2d()->getImageData(0, 0, 1, 1, exception_state);
     CanvasElement().FinalizeFrame();
 
     EXPECT_FALSE(exception_state.HadException());
-    EXPECT_TRUE(CanvasElement().Buffer()->IsAccelerated());
+    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) {
-    EXPECT_FALSE(CanvasElement().Buffer()->IsAccelerated());
+    EXPECT_FALSE(CanvasElement().GetImageBuffer()->IsAccelerated());
     EXPECT_EQ(0u, GetGlobalAcceleratedImageBufferCount());
     EXPECT_EQ(0, GetGlobalGPUMemoryUsage());
   } else {
-    EXPECT_TRUE(CanvasElement().Buffer()->IsAccelerated());
+    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) {
@@ skipping 26 matching lines @@
     std::unique_ptr<FakeWebGraphicsContext3DProvider> context_provider(
         new FakeWebGraphicsContext3DProvider(&gl));
     IntSize size(dst_size, dst_size);
     RefPtr<Canvas2DLayerBridge> bridge =
         MakeBridge(std::move(context_provider), size,
                    Canvas2DLayerBridge::kEnableAcceleration);
     std::unique_ptr<Canvas2DImageBufferSurface> surface(
         new Canvas2DImageBufferSurface(bridge, size));
     CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
-    EXPECT_TRUE(CanvasElement().Buffer()->IsAccelerated());
+    EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
     EXPECT_EQ(1u, GetGlobalAcceleratedImageBufferCount());
     // 4 bytes per pixel * 2 buffers = 8
     EXPECT_EQ(8 * dst_size * dst_size, GetGlobalGPUMemoryUsage());
     sk_sp<SkSurface> sk_surface =
         SkSurface::MakeRasterN32Premul(src_size, src_size);
     RefPtr<StaticBitmapImage> big_bitmap =
         StaticBitmapImage::Create(sk_surface->makeImageSnapshot());
     ImageBitmap* big_image = ImageBitmap::Create(std::move(big_bitmap));
     NonThrowableExceptionState exception_state;
     V8TestingScope scope;
     Context2d()->drawImage(scope.GetScriptState(), big_image, 0, 0, src_size,
                            src_size, 0, 0, dst_size, dst_size, exception_state);
     EXPECT_FALSE(exception_state.HadException());
 
     if (test_variant == kLargeTextureDisablesAcceleration) {
-      EXPECT_FALSE(CanvasElement().Buffer()->IsAccelerated());
+      EXPECT_FALSE(CanvasElement().GetImageBuffer()->IsAccelerated());
       EXPECT_EQ(0u, GetGlobalAcceleratedImageBufferCount());
       EXPECT_EQ(0, GetGlobalGPUMemoryUsage());
     } else {
-      EXPECT_TRUE(CanvasElement().Buffer()->IsAccelerated());
+      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,
@@ skipping 41 matching lines @@
       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());
 
   context->fillRect(10, 10, 100, 100);
-  EXPECT_TRUE(CanvasElement().Buffer()->IsAccelerated());
+  EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
 
-  CanvasElement().Buffer()->DisableAcceleration();
-  EXPECT_FALSE(CanvasElement().Buffer()->IsAccelerated());
+  CanvasElement().GetImageBuffer()->DisableAcceleration();
+  EXPECT_FALSE(CanvasElement().GetImageBuffer()->IsAccelerated());
 
   context->fillRect(10, 10, 100, 100);
 
   EXPECT_EQ(0, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(0, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(0u, GetGlobalAcceleratedImageBufferCount());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        LegacyColorSpaceUsesGlobalTargetColorBehavior) {
@@ skipping 537 matching lines @@
   IntSize size(300, 300);
   RefPtr<Canvas2DLayerBridge> bridge =
       MakeBridge(std::move(context_provider), size,
                  Canvas2DLayerBridge::kEnableAcceleration);
   // Force hibernatation to occur in an immediate task.
   bridge->DontUseIdleSchedulingForTesting();
   std::unique_ptr<Canvas2DImageBufferSurface> surface(
       new Canvas2DImageBufferSurface(bridge, size));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
-  EXPECT_TRUE(CanvasElement().Buffer()->IsAccelerated());
+  EXPECT_TRUE(CanvasElement().GetImageBuffer()->IsAccelerated());
 
   EXPECT_TRUE(CanvasElement().GetLayoutBoxModelObject());
   PaintLayer* layer = CanvasElement().GetLayoutBoxModelObject()->Layer();
   EXPECT_TRUE(layer);
   GetDocument().View()->UpdateAllLifecyclePhases();
 
   // Hide element to trigger hibernation (if enabled).
   GetDocument().GetPage()->SetVisibilityState(kPageVisibilityStateHidden,
                                               false);
   RunUntilIdle();  // Run hibernation task.
   // If enabled, hibernation should cause compositing update.
   EXPECT_EQ(!!CANVAS2D_HIBERNATION_ENABLED,
             layer->NeedsCompositingInputsUpdate());
 
   GetDocument().View()->UpdateAllLifecyclePhases();
   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());
   RunUntilIdle();  // Clear task queue.
 }
 
 }  // namespace blink