Add some plumbing for the color management of 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 "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 168 matching lines @@
 }
 
 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));
+    return adoptRef(new Canvas2DLayerBridge(std::move(provider), size, 0, NonOpaque, accelerationMode, nullptr));
 }
 
 //============================================================================
 
 class FakeAcceleratedImageBufferSurfaceForTesting : public UnacceleratedImageBufferSurface {
 public:
     FakeAcceleratedImageBufferSurfaceForTesting(const IntSize& size, OpacityMode mode)
         : UnacceleratedImageBufferSurface(size, mode)
         , m_isAccelerated(true) { }
     ~FakeAcceleratedImageBufferSurfaceForTesting() override { }
@@ skipping 69 matching lines @@
 //============================================================================
 
 class MockSurfaceFactory : public RecordingImageBufferFallbackSurfaceFactory {
 public:
     enum FallbackExpectation {
         ExpectFallback,
         ExpectNoFallback
     };
     static std::unique_ptr<MockSurfaceFactory> create(FallbackExpectation expectation) { return wrapUnique(new MockSurfaceFactory(expectation)); }
 
-    std::unique_ptr<ImageBufferSurface> createSurface(const IntSize& size, OpacityMode mode) override
+    std::unique_ptr<ImageBufferSurface> createSurface(const IntSize& size, OpacityMode mode, sk_sp<SkColorSpace> colorSpace) override
     {
         EXPECT_EQ(ExpectFallback, m_expectation);
         m_didFallback = true;
-        return wrapUnique(new UnacceleratedImageBufferSurface(size, mode));
+        return wrapUnique(new UnacceleratedImageBufferSurface(size, mode, InitializeImagePixels, colorSpace));
     }
 
     ~MockSurfaceFactory() override
     {
         if (m_expectation == ExpectFallback) {
             EXPECT_TRUE(m_didFallback);
         }
     }
 
 private:
@@ skipping 119 matching lines @@
     // Test composite operators with an opaque rect that does not cover the entire canvas
     TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("clear")), fillRect(0, 0, 5, 5));
     TEST_OVERDRAW_2(1, setGlobalCompositeOperation(String("copy")), fillRect(0, 0, 5, 5));
     TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-over")), fillRect(0, 0, 5, 5));
     TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-in")), fillRect(0, 0, 5, 5));
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionByDefault)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderOverdrawLimit)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->setGlobalAlpha(0.5f); // To prevent overdraw optimization
     for (int i = 0; i < ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold - 1; i++) {
         context2d()->fillRect(0, 0, 10, 10);
     }
 
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverOverdrawLimit)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->setGlobalAlpha(0.5f); // To prevent overdraw optimization
     for (int i = 0; i < ExpensiveCanvasHeuristicParameters::ExpensiveOverdrawThreshold; i++) {
         context2d()->fillRect(0, 0, 10, 10);
     }
 
     EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderImageSizeRatioLimit)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     NonThrowableExceptionState exceptionState;
     Element* sourceCanvasElement = document().createElement("canvas", exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
     HTMLCanvasElement* sourceCanvas = static_cast<HTMLCanvasElement*>(sourceCanvasElement);
     IntSize sourceSize(10, 10 * ExpensiveCanvasHeuristicParameters::ExpensiveImageSizeRatio);
     std::unique_ptr<UnacceleratedImageBufferSurface> sourceSurface = wrapUnique(new UnacceleratedImageBufferSurface(sourceSize, NonOpaque));
     sourceCanvas->createImageBufferUsingSurfaceForTesting(std::move(sourceSurface));
 
     const ImageBitmapOptions defaultOptions;
     Optional<IntRect> cropRect = IntRect(IntPoint(0, 0), sourceSize);
     // Go through an ImageBitmap to avoid triggering a display list fallback
     ImageBitmap* sourceImageBitmap = ImageBitmap::create(sourceCanvas, cropRect, defaultOptions);
 
     context2d()->drawImage(canvasElement().getExecutionContext(), sourceImageBitmap, 0, 0, 1, 1, 0, 0, 1, 1, exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
 
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverImageSizeRatioLimit)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     NonThrowableExceptionState exceptionState;
     Element* sourceCanvasElement = document().createElement("canvas", exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
     HTMLCanvasElement* sourceCanvas = static_cast<HTMLCanvasElement*>(sourceCanvasElement);
     IntSize sourceSize(10, 10 * ExpensiveCanvasHeuristicParameters::ExpensiveImageSizeRatio + 1);
     std::unique_ptr<UnacceleratedImageBufferSurface> sourceSurface = wrapUnique(new UnacceleratedImageBufferSurface(sourceSize, NonOpaque));
     sourceCanvas->createImageBufferUsingSurfaceForTesting(std::move(sourceSurface));
 
     const ImageBitmapOptions defaultOptions;
     Optional<IntRect> cropRect = IntRect(IntPoint(0, 0), sourceSize);
     // Go through an ImageBitmap to avoid triggering a display list fallback
     ImageBitmap* sourceImageBitmap = ImageBitmap::create(sourceCanvas, cropRect, defaultOptions);
 
     context2d()->drawImage(canvasElement().getExecutionContext(), sourceImageBitmap, 0, 0, 1, 1, 0, 0, 1, 1, exceptionState);
     EXPECT_FALSE(exceptionState.hadException());
 
     EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderExpensivePathPointCount)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->beginPath();
     context2d()->moveTo(7, 5);
     for (int i = 1; i < ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount-1; i++) {
         float angleRad = twoPiFloat * i / (ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount - 1);
         context2d()->lineTo(5 + 2 * cos(angleRad), 5 + 2 * sin(angleRad));
     }
     context2d()->fill();
 
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverExpensivePathPointCount)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->beginPath();
     context2d()->moveTo(7, 5);
     for (int i = 1; i < ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount + 1; i++) {
         float angleRad = twoPiFloat * i / (ExpensiveCanvasHeuristicParameters::ExpensivePathPointCount + 1);
         context2d()->lineTo(5 + 2 * cos(angleRad), 5 + 2 * sin(angleRad));
     }
     context2d()->fill();
 
     EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWhenPathIsConcave)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->beginPath();
     context2d()->moveTo(1, 1);
     context2d()->lineTo(5, 5);
     context2d()->lineTo(9, 1);
     context2d()->lineTo(5, 9);
     context2d()->fill();
 
     if (ExpensiveCanvasHeuristicParameters::ConcavePathsAreExpensive) {
         EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
     } else {
         EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
     }
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithRectangleClip)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->beginPath();
     context2d()->rect(1, 1, 2, 2);
     context2d()->clip();
     context2d()->fillRect(0, 0, 4, 4);
 
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithComplexClip)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->beginPath();
     context2d()->moveTo(1, 1);
     context2d()->lineTo(5, 5);
     context2d()->lineTo(9, 1);
     context2d()->lineTo(5, 9);
     context2d()->clip();
     context2d()->fillRect(0, 0, 4, 4);
 
     if (ExpensiveCanvasHeuristicParameters::ComplexClipsAreExpensive) {
         EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
     } else {
         EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
     }
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithBlurredShadow)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->setShadowColor(String("red"));
     context2d()->setShadowBlur(1.0f);
     context2d()->fillRect(1, 1, 1, 1);
 
     if (ExpensiveCanvasHeuristicParameters::BlurredShadowsAreExpensive) {
         EXPECT_TRUE(canvasElement().shouldBeDirectComposited());
     } else {
         EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
     }
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithSharpShadow)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->setShadowColor(String("red"));
     context2d()->setShadowOffsetX(1.0f);
     context2d()->fillRect(1, 1, 1, 1);
 
     EXPECT_FALSE(canvasElement().shouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoFallbackWithSmallState)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->fillRect(0, 0, 1, 1); // To have a non-empty dirty rect
     for (int i = 0; i < ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth - 1; ++i) {
         context2d()->save();
         context2d()->translate(1.0f, 0.0f);
     }
     canvasElement().doDeferredPaintInvalidation(); // To close the current frame
 }
 
 TEST_F(CanvasRenderingContext2DTest, FallbackWithLargeState)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->fillRect(0, 0, 1, 1); // To have a non-empty dirty rect
     for (int i = 0; i < ExpensiveCanvasHeuristicParameters::ExpensiveRecordingStackDepth; ++i) {
         context2d()->save();
         context2d()->translate(1.0f, 0.0f);
     }
     canvasElement().doDeferredPaintInvalidation(); // To close the current frame
 }
 
 TEST_F(CanvasRenderingContext2DTest, OpaqueDisplayListFallsBackForText)
 {
     // Verify that drawing text to an opaque canvas, which is expected to
     // render with subpixel text anti-aliasing, results in falling out
     // of display list mode because the current diplay list implementation
     // does not support pixel geometry settings.
     // See: crbug.com/583809
     createContext(Opaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectFallback), Opaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectFallback), Opaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->fillText("Text", 0, 5);
 }
 
 TEST_F(CanvasRenderingContext2DTest, NonOpaqueDisplayListDoesNotFallBackForText)
 {
     createContext(NonOpaque);
-    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque));
+    std::unique_ptr<RecordingImageBufferSurface> surface = wrapUnique(new RecordingImageBufferSurface(IntSize(10, 10), MockSurfaceFactory::create(MockSurfaceFactory::ExpectNoFallback), NonOpaque, nullptr));
     canvasElement().createImageBufferUsingSurfaceForTesting(std::move(surface));
 
     context2d()->fillText("Text", 0, 5);
 }
 
 TEST_F(CanvasRenderingContext2DTest, ImageResourceLifetime)
 {
     NonThrowableExceptionState nonThrowableExceptionState;
     Element* canvasElement = document().createElement("canvas", nonThrowableExceptionState);
     EXPECT_FALSE(nonThrowableExceptionState.hadException());
@@ skipping 172 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