Cancel GPU acceleration for 2D canvas when drawing very large images

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/dom/Document.h"
 #include "core/fetch/MemoryCache.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
@@ skipping 29 matching lines @@
 
 class FakeImageSource : public CanvasImageSource {
 public:
     FakeImageSource(IntSize, BitmapOpacity);
 
     PassRefPtr<Image> getSourceImageForCanvas(SourceImageStatus*, AccelerationHint, SnapshotReason, const FloatSize&) const override;
 
     bool wouldTaintOrigin(SecurityOrigin* destinationSecurityOrigin) const override { return false; }
     FloatSize elementSize(const FloatSize&) const override { return FloatSize(m_size); }
     bool isOpaque() const override { return m_isOpaque; }
+    bool isAccelerated() const { return false; }
     int sourceWidth() override { return m_size.width(); }
     int sourceHeight() override { return m_size.height(); }
 
     ~FakeImageSource() override { }
 
 private:
     IntSize m_size;
     RefPtr<Image> m_image;
     bool m_isOpaque;
 };
@@ skipping 732 matching lines @@
     } else {
         EXPECT_TRUE(canvasElement().buffer()->isAccelerated());
         EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
         EXPECT_EQ(720000, getGlobalGPUMemoryUsage());
     }
 
     // Restore global state to prevent side-effects on other tests
     RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(savedFixedRenderingMode);
 }
 
+TEST_F(CanvasRenderingContext2DTest, LargeTextureUploadDisablesAcceleration)
+{

[xidachen, 2016/09/24 01:36:34]

I can see that these two tests are sharing a lot of common code. Is there a way
to share some code in unit tests?

+    bool savedFixedRenderingMode = RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled();
+    RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(false);
+
+    int srcDim = sqrt(ExpensiveCanvasHeuristicParameters::DrawImageTextureUploadSoftSizeLimit) + 1;
+    int dstDim = srcDim / sqrt(ExpensiveCanvasHeuristicParameters::DrawImageTextureUploadSoftSizeLimitScaleThreshold) - 1;
+
+    createContext(NonOpaque);
+    FakeGLES2Interface gl;
+    std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider(new FakeWebGraphicsContext3DProvider(&gl));
+    IntSize size(dstDim, dstDim);

[xidachen, 2016/09/24 01:36:34]

Could we name this dstSize?

+    RefPtr<Canvas2DLayerBridge> bridge = makeBridge(std::move(contextProvider), size, Canvas2DLayerBridge::EnableAcceleration);
+    std::unique_ptr<Canvas2DImageBufferSurface> surface(new Canvas2DImageBufferSurface(bridge, size));
+    canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
+
+    EXPECT_TRUE(canvasElement().buffer()->isAccelerated());
+    EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
+    EXPECT_EQ(8*dstDim*dstDim, getGlobalGPUMemoryUsage());

[xidachen, 2016/09/24 01:36:34]

I don't quite understand why is this *8? My impression is number of pixels *
number of channels (*4).

+    sk_sp<SkSurface> skSurface = SkSurface::MakeRasterN32Premul(srcDim, srcDim);
+    RefPtr<StaticBitmapImage> bigBitmap = StaticBitmapImage::create(skSurface->makeImageSnapshot());
+    ImageBitmap* bigImage = ImageBitmap::create(std::move(bigBitmap));
+    NonThrowableExceptionState exceptionState;
+    context2d()->drawImage(nullptr, bigImage, 0, 0, srcDim, srcDim, 0, 0, dstDim, dstDim, exceptionState);
+    EXPECT_FALSE(exceptionState.hadException());
+
+    EXPECT_TRUE(!canvasElement().buffer()->isAccelerated());

[xidachen, 2016/09/24 01:36:34]

Maybe change to EXPECT_FALSE(canvasElement().buffer()->isAccelerated())?

+    EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
+    EXPECT_EQ(0, getGlobalGPUMemoryUsage());
+
+    // Restore global state to prevent side-effects on other tests
+    RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(savedFixedRenderingMode);
+}
+
+TEST_F(CanvasRenderingContext2DTest, SmallTextureUploadDoesNotDisableAcceleration)
+{
+    bool savedFixedRenderingMode = RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled();
+    RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(false);
+
+    int srcDim = sqrt(ExpensiveCanvasHeuristicParameters::DrawImageTextureUploadSoftSizeLimit) - 1;
+    int dstDim = srcDim / sqrt(ExpensiveCanvasHeuristicParameters::DrawImageTextureUploadSoftSizeLimitScaleThreshold) + 1;
+
+    createContext(NonOpaque);
+    FakeGLES2Interface gl;
+    std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider(new FakeWebGraphicsContext3DProvider(&gl));
+    IntSize size(dstDim, dstDim);

[xidachen, 2016/09/24 01:36:34]

dstSize?

+    RefPtr<Canvas2DLayerBridge> bridge = makeBridge(std::move(contextProvider), size, Canvas2DLayerBridge::EnableAcceleration);
+    std::unique_ptr<Canvas2DImageBufferSurface> surface(new Canvas2DImageBufferSurface(bridge, size));
+    canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
+
+    EXPECT_TRUE(canvasElement().buffer()->isAccelerated());
+    EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
+    EXPECT_EQ(8*dstDim*dstDim, getGlobalGPUMemoryUsage());
+    sk_sp<SkSurface> skSurface = SkSurface::MakeRasterN32Premul(srcDim, srcDim);
+    RefPtr<StaticBitmapImage> bigBitmap = StaticBitmapImage::create(skSurface->makeImageSnapshot());
+    ImageBitmap* bigImage = ImageBitmap::create(std::move(bigBitmap));
+    NonThrowableExceptionState exceptionState;
+    context2d()->drawImage(nullptr, bigImage, 0, 0, srcDim, srcDim, 0, 0, dstDim, dstDim, exceptionState);
+    EXPECT_FALSE(exceptionState.hadException());
+
+    EXPECT_TRUE(canvasElement().buffer()->isAccelerated());
+    EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
+    EXPECT_EQ(8*dstDim*dstDim, getGlobalGPUMemoryUsage());
+
+    // Restore global state to prevent side-effects on other tests
+    RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(savedFixedRenderingMode);
+}
+
 TEST_F(CanvasRenderingContext2DTest, IsAccelerationOptimalForCanvasContentHeuristic)
 {
     createContext(NonOpaque);
 
     std::unique_ptr<FakeAcceleratedImageBufferSurfaceForTesting> fakeAccelerateSurface = wrapUnique(new FakeAcceleratedImageBufferSurfaceForTesting(IntSize(10, 10), NonOpaque));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(fakeAccelerateSurface));
 
     NonThrowableExceptionState exceptionState;
 
     CanvasRenderingContext2D* context = context2d();
@@ skipping 40 matching lines @@
     EXPECT_FALSE(canvasElement().buffer()->isAccelerated());
 
     context->fillRect(10, 10, 100, 100);
 
     EXPECT_EQ(0, getCurrentGPUMemoryUsage());
     EXPECT_EQ(0, getGlobalGPUMemoryUsage());
     EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
 }
 
 } // namespace blink