Limit the number of accelerated canvases that can exist in a render process

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 "core/fetch/MemoryCache.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 62 matching lines @@
 class CanvasRenderingContext2DTest : public ::testing::Test {
 protected:
     CanvasRenderingContext2DTest();
     void SetUp() override;
 
     DummyPageHolder& page() const { return *m_dummyPageHolder; }
     HTMLDocument& document() const { return *m_document; }
     HTMLCanvasElement& canvasElement() const { return *m_canvasElement; }
     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(); }
 
     void createContext(OpacityMode);
     void TearDown();
 
 private:
     OwnPtr<DummyPageHolder> m_dummyPageHolder;
     Persistent<HTMLDocument> m_document;
     Persistent<HTMLCanvasElement> m_canvasElement;
     Persistent<MemoryCache> m_globalMemoryCache;
@@ skipping 590 matching lines @@
 {
     createContext(NonOpaque);
 
     OwnPtr<FakeAcceleratedImageBufferSurfaceForTesting> fakeAccelerateSurface = adoptPtr(new FakeAcceleratedImageBufferSurfaceForTesting(IntSize(10, 10), NonOpaque));
     FakeAcceleratedImageBufferSurfaceForTesting* fakeAccelerateSurfacePtr = fakeAccelerateSurface.get();
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(fakeAccelerateSurface));
     // 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
     fakeAccelerateSurfacePtr->setIsAccelerated(false);
     canvasElement().buffer()->updateGPUMemoryUsage();
     EXPECT_EQ(0, getCurrentGPUMemoryUsage());
     EXPECT_EQ(0, getGlobalGPUMemoryUsage());
+    EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
 
     // Switching non-accelerated mode to accelerated mode
     fakeAccelerateSurfacePtr->setIsAccelerated(true);
     canvasElement().buffer()->updateGPUMemoryUsage();
     EXPECT_EQ(800, getCurrentGPUMemoryUsage());
     EXPECT_EQ(800, getGlobalGPUMemoryUsage());
+    EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
 
     // Creating a different accelerated image buffer
     OwnPtr<FakeAcceleratedImageBufferSurfaceForTesting> fakeAccelerateSurface2 = adoptPtr(new FakeAcceleratedImageBufferSurfaceForTesting(IntSize(10, 5), NonOpaque));
     OwnPtr<ImageBuffer> imageBuffer2 = ImageBuffer::create(std::move(fakeAccelerateSurface2));
     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(fakeAccelerateSurfacePtr);
     EXPECT_EQ(400, getGlobalGPUMemoryUsage());
+    EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
 
     // Tear down the second image buffer
     imageBuffer2.reset();
     EXPECT_EQ(0, getGlobalGPUMemoryUsage());
+    EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
 }
 
 } // namespace blink