Make 2D canvas disable gpu acceleration when getImageData is called

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"
 #include "core/html/HTMLDocument.h"
 #include "core/html/ImageData.h"
 #include "core/imagebitmap/ImageBitmapOptions.h"
 #include "core/loader/EmptyClients.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/canvas2d/CanvasGradient.h"
 #include "modules/canvas2d/CanvasPattern.h"
 #include "modules/webgl/WebGLRenderingContext.h"
+#include "platform/graphics/Canvas2DImageBufferSurface.h"
 #include "platform/graphics/ExpensiveCanvasHeuristicParameters.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "platform/graphics/StaticBitmapImage.h"
 #include "platform/graphics/UnacceleratedImageBufferSurface.h"
+#include "platform/graphics/test/FakeGLES2Interface.h"
+#include "platform/graphics/test/FakeWebGraphicsContext3DProvider.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "wtf/PtrUtil.h"
 #include <memory>
 
 using ::testing::Mock;
 
 namespace blink {
 
@@ skipping 48 matching lines @@
     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();
     void unrefCanvas();
+    PassRefPtr<Canvas2DLayerBridge> makeBridge(std::unique_ptr<FakeWebGraphicsContext3DProvider>, const IntSize&, Canvas2DLayerBridge::AccelerationMode);
 
 private:
     std::unique_ptr<DummyPageHolder> m_dummyPageHolder;
     Persistent<HTMLDocument> m_document;
     Persistent<HTMLCanvasElement> m_canvasElement;
     Persistent<MemoryCache> m_globalMemoryCache;
 
     class WrapGradients final : public GarbageCollectedFinalized<WrapGradients> {
     public:
         static WrapGradients* create()
@@ skipping 70 matching lines @@
 
     m_globalMemoryCache = replaceMemoryCacheForTesting(MemoryCache::create());
 }
 
 void CanvasRenderingContext2DTest::TearDown()
 {
     ThreadHeap::collectGarbage(BlinkGC::NoHeapPointersOnStack, BlinkGC::GCWithSweep, BlinkGC::ForcedGC);
     replaceMemoryCacheForTesting(m_globalMemoryCache.release());
 }
 
+PassRefPtr<Canvas2DLayerBridge> CanvasRenderingContext2DTest::makeBridge(std::unique_ptr<FakeWebGraphicsContext3DProvider> provider, const IntSize& size, Canvas2DLayerBridge::AccelerationMode accelerationMode)
+{
+    return adoptRef(new Canvas2DLayerBridge(std::move(provider), size, 0, NonOpaque, accelerationMode));
+}
+
 //============================================================================
 
 class FakeAcceleratedImageBufferSurfaceForTesting : public UnacceleratedImageBufferSurface {
 public:
     FakeAcceleratedImageBufferSurfaceForTesting(const IntSize& size, OpacityMode mode)
         : UnacceleratedImageBufferSurface(size, mode)
         , m_isAccelerated(true) { }
     ~FakeAcceleratedImageBufferSurfaceForTesting() override { }
     bool isAccelerated() const override { return m_isAccelerated; }
     void setIsAccelerated(bool isAccelerated)
@@ skipping 553 matching lines @@
 }
 
 TEST_F(CanvasRenderingContext2DTest, ContextDisposedBeforeCanvas)
 {
     createContext(NonOpaque);
 
     canvasElement().detachContext();
     // Passes by not crashing later during teardown
 }
 
+TEST_F(CanvasRenderingContext2DTest, GetImageDataDisablesAcceleration)
+{
+    createContext(NonOpaque);
+    FakeGLES2Interface gl;
+    std::unique_ptr<FakeWebGraphicsContext3DProvider> contextProvider(new FakeWebGraphicsContext3DProvider(&gl));
+    IntSize size(300, 300);
+    RefPtr<Canvas2DLayerBridge> bridge = makeBridge(std::move(contextProvider), size, Canvas2DLayerBridge::EnableAcceleration);
+    std::unique_ptr<Canvas2DImageBufferSurface> surface(new Canvas2DImageBufferSurface(bridge, size, NonOpaque));
+    canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
+
+    EXPECT_TRUE(bridge->isAccelerated());
+    EXPECT_EQ(1u, getGlobalAcceleratedImageBufferCount());
+    EXPECT_EQ(720000, getGlobalGPUMemoryUsage());
+
+    bool savedValue = RuntimeEnabledFeatures::canvas2dFixedRenderingModeEnabled();
+    RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(false);

[xlai (Olivia), 2016/06/23 19:55:02]

Nits: Why don't you set the Canvas2dFixedRenderingModeEnabled=false at the
beginning of the test (before 773)? In theory, as long as you don't call
getImageData, the ForceDisableAcceleration should not happen.

[Justin Novosad, 2016/06/23 21:02:09]

Done.

+    TrackExceptionState exceptionState;
+    context2d()->getImageData(0, 0, 1, 1, exceptionState);
+    RuntimeEnabledFeatures::setCanvas2dFixedRenderingModeEnabled(savedValue);
+
+    EXPECT_FALSE(exceptionState.hadException());
+    EXPECT_FALSE(bridge->isAccelerated());
+    EXPECT_EQ(0u, getGlobalAcceleratedImageBufferCount());
+    EXPECT_EQ(0, getGlobalGPUMemoryUsage());
+}
+
 } // namespace blink