Fixing laggy chrome on a multitude of accelerated canvases

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 "config.h"
 #include "modules/canvas2d/CanvasRenderingContext2D.h"
 
 #include "core/fetch/MemoryCache.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
@@ skipping 61 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 getTotalGPUMemoryUsage() const { return ImageBuffer::getTotalGPUMemoryUsage(); }
+    intptr_t getCurrGPUMemoryUsage() const { return canvasElement().buffer()->getGPUMemoryUsage(); }

[Justin Novosad, 2015/12/08 22:15:27]

Curr -> Current

 
     void createContext(OpacityMode);
     void TearDown();
 
 private:
     OwnPtr<DummyPageHolder> m_dummyPageHolder;
     RefPtrWillBePersistent<HTMLDocument> m_document;
     RefPtrWillBePersistent<HTMLCanvasElement> m_canvasElement;
     Persistent<MemoryCache> m_globalMemoryCache;
 
@@ skipping 75 matching lines @@
 }
 
 void CanvasRenderingContext2DTest::TearDown()
 {
     Heap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
     replaceMemoryCacheForTesting(m_globalMemoryCache.release());
 }
 
 //============================================================================
 
+class FakeAcceleratedImageBufferSurfaceForOverwriteTesting : public UnacceleratedImageBufferSurface {

[Justin Novosad, 2015/12/08 22:15:27]

Bad name, this is not for overwrite testing

+public:
+    FakeAcceleratedImageBufferSurfaceForOverwriteTesting(const IntSize& size, OpacityMode mode) : UnacceleratedImageBufferSurface(size, mode) { }
+    ~FakeAcceleratedImageBufferSurfaceForOverwriteTesting() override { }
+    bool isAccelerated() const override { return true; }

[Justin Novosad, 2015/12/08 22:15:27]

you need a "setIsAccelerated" to go with this in order to test the case where an
accelerated surface switches to be non-accelerated.

+
+    MOCK_METHOD0(willOverwriteCanvas, void());

[Justin Novosad, 2015/12/08 22:15:27]

this is not needed.

+};
+
+//============================================================================
+
 class MockImageBufferSurfaceForOverwriteTesting : public UnacceleratedImageBufferSurface {
 public:
     MockImageBufferSurfaceForOverwriteTesting(const IntSize& size, OpacityMode mode) : UnacceleratedImageBufferSurface(size, mode) { }
     ~MockImageBufferSurfaceForOverwriteTesting() override { }
     bool isRecording() const override { return true; } // otherwise overwrites are not tracked
 
     MOCK_METHOD0(willOverwriteCanvas, void());
 };
 
 //============================================================================
@@ skipping 435 matching lines @@
         imageBitmapDerived = ImageBitmap::create(imageBitmapFromCanvas.get(), IntRect(0, 0, 20, 20));
     }
     CanvasContextCreationAttributes attributes;
     CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(canvasElement->getCanvasRenderingContext("2d", attributes));
     TrackExceptionState exceptionState;
     CanvasImageSourceUnion imageSource;
     imageSource.setImageBitmap(imageBitmapDerived);
     context->drawImage(imageSource, 0, 0, exceptionState);
 }
 
+TEST_F(CanvasRenderingContext2DTest, GPUMemoryUpdateForAcceleratedCanvas)
+{
+    createContext(NonOpaque);
+
+    OwnPtr<FakeAcceleratedImageBufferSurfaceForOverwriteTesting> fakeAccelerateSurface = adoptPtr(new FakeAcceleratedImageBufferSurfaceForOverwriteTesting(IntSize(10, 10), NonOpaque));
+    FakeAcceleratedImageBufferSurfaceForOverwriteTesting* fakeAccelerateSurfacePtr = fakeAccelerateSurface.get();
+    canvasElement().createImageBufferUsingSurfaceForTesting(fakeAccelerateSurface.release());
+
+    // 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, getCurrGPUMemoryUsage());
+    EXPECT_EQ(800, getTotalGPUMemoryUsage()); 
+
+    OwnPtr<FakeAcceleratedImageBufferSurfaceForOverwriteTesting> fakeAccelerateSurface2 = adoptPtr(new FakeAcceleratedImageBufferSurfaceForOverwriteTesting(IntSize(10, 5), NonOpaque));
+    OwnPtr<ImageBuffer> imageBuffer = ImageBuffer::create(fakeAccelerateSurface2.release());
+
+    EXPECT_EQ(800, getCurrGPUMemoryUsage());
+    EXPECT_EQ(1200, getTotalGPUMemoryUsage());
+
+    canvasElement().setSize(IntSize(20, 20));
+    Mock::VerifyAndClearExpectations(fakeAccelerateSurfacePtr);
+
+    EXPECT_EQ(400, getTotalGPUMemoryUsage());
+
+    imageBuffer.clear();
+
+    EXPECT_EQ(0, getTotalGPUMemoryUsage());
+}
+
 } // namespace blink