Plumb CanvasColorParams to canvas image classes

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 <memory>
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/Document.h"
@@ skipping 225 matching lines @@
   ThreadState::Current()->CollectGarbage(BlinkGC::kNoHeapPointersOnStack,
                                          BlinkGC::kGCWithSweep,
                                          BlinkGC::kForcedGC);
   ReplaceMemoryCacheForTesting(global_memory_cache_.Release());
 }
 
 PassRefPtr<Canvas2DLayerBridge> CanvasRenderingContext2DTest::MakeBridge(
     std::unique_ptr<FakeWebGraphicsContext3DProvider> provider,
     const IntSize& size,
     Canvas2DLayerBridge::AccelerationMode acceleration_mode) {
-  return AdoptRef(new Canvas2DLayerBridge(
-      std::move(provider), size, 0, kNonOpaque, acceleration_mode,
-      gfx::ColorSpace::CreateSRGB(), false, kN32_SkColorType));
+  return AdoptRef(new Canvas2DLayerBridge(std::move(provider), size, 0,
+                                          kNonOpaque, acceleration_mode,
+                                          CanvasColorParams()));
 }
 
 //============================================================================
 
 class FakeAcceleratedImageBufferSurfaceForTesting
     : public UnacceleratedImageBufferSurface {
  public:
   FakeAcceleratedImageBufferSurfaceForTesting(const IntSize& size,
                                               OpacityMode mode)
       : UnacceleratedImageBufferSurface(size, mode), is_accelerated_(true) {}
@@ skipping 80 matching lines @@
  public:
   enum FallbackExpectation { kExpectFallback, kExpectNoFallback };
   static std::unique_ptr<MockSurfaceFactory> Create(
       FallbackExpectation expectation) {
     return WTF::WrapUnique(new MockSurfaceFactory(expectation));
   }
 
   std::unique_ptr<ImageBufferSurface> CreateSurface(
       const IntSize& size,
       OpacityMode mode,
-      sk_sp<SkColorSpace> color_space,
-      SkColorType color_type) override {
+      const CanvasColorParams& color_params) override {
     EXPECT_EQ(kExpectFallback, expectation_);
     did_fallback_ = true;
     return WTF::WrapUnique(new UnacceleratedImageBufferSurface(
-        size, mode, kInitializeImagePixels, color_space, color_type));
+        size, mode, kInitializeImagePixels, color_params));
   }
 
   ~MockSurfaceFactory() override {
     if (expectation_ == kExpectFallback) {
       EXPECT_TRUE(did_fallback_);
     }
   }
 
  private:
   MockSurfaceFactory(FallbackExpectation expectation)
@@ skipping 177 matching lines @@
   TEST_OVERDRAW_2(0, setGlobalCompositeOperation(String("source-in")),
                   fillRect(0, 0, 5, 5));
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionByDefault) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderOverdrawLimit) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->setGlobalAlpha(0.5f);  // To prevent overdraw optimization
   for (int i = 0;
        i < ExpensiveCanvasHeuristicParameters::kExpensiveOverdrawThreshold - 1;
        i++) {
     Context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverOverdrawLimit) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->setGlobalAlpha(0.5f);  // To prevent overdraw optimization
   for (int i = 0;
        i < ExpensiveCanvasHeuristicParameters::kExpensiveOverdrawThreshold;
        i++) {
     Context2d()->fillRect(0, 0, 10, 10);
   }
 
   EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionUnderImageSizeRatioLimit) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   NonThrowableExceptionState exception_state;
   Element* source_canvas_element =
       GetDocument().createElement("canvas", exception_state);
   EXPECT_FALSE(exception_state.HadException());
   HTMLCanvasElement* source_canvas =
       static_cast<HTMLCanvasElement*>(source_canvas_element);
   IntSize source_size(
       10, 10 * ExpensiveCanvasHeuristicParameters::kExpensiveImageSizeRatio);
@@ skipping 14 matching lines @@
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionOverImageSizeRatioLimit) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   NonThrowableExceptionState exception_state;
   Element* source_canvas_element =
       GetDocument().createElement("canvas", exception_state);
   EXPECT_FALSE(exception_state.HadException());
   HTMLCanvasElement* source_canvas =
       static_cast<HTMLCanvasElement*>(source_canvas_element);
   IntSize source_size(
       10,
@@ skipping 16 matching lines @@
   EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        NoLayerPromotionUnderExpensivePathPointCount) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->beginPath();
   Context2d()->moveTo(7, 5);
   for (int i = 1;
        i < ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount - 1;
        i++) {
     float angle_rad =
         twoPiFloat * i /
         (ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount - 1);
     Context2d()->lineTo(5 + 2 * cos(angle_rad), 5 + 2 * sin(angle_rad));
   }
   Context2d()->fill();
 
   EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        LayerPromotionOverExpensivePathPointCount) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->beginPath();
   Context2d()->moveTo(7, 5);
   for (int i = 1;
        i < ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount + 1;
        i++) {
     float angle_rad =
         twoPiFloat * i /
         (ExpensiveCanvasHeuristicParameters::kExpensivePathPointCount + 1);
     Context2d()->lineTo(5 + 2 * cos(angle_rad), 5 + 2 * sin(angle_rad));
   }
   Context2d()->fill();
 
   EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWhenPathIsConcave) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   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::kConcavePathsAreExpensive) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithRectangleClip) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   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(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   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::kComplexClipsAreExpensive) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
 }
 
 TEST_F(CanvasRenderingContext2DTest, LayerPromotionWithBlurredShadow) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->setShadowColor(String("red"));
   Context2d()->setShadowBlur(1.0f);
   Context2d()->fillRect(1, 1, 1, 1);
 
   if (ExpensiveCanvasHeuristicParameters::kBlurredShadowsAreExpensive) {
     EXPECT_TRUE(CanvasElement().ShouldBeDirectComposited());
   } else {
     EXPECT_FALSE(CanvasElement().ShouldBeDirectComposited());
   }
 }
 
 TEST_F(CanvasRenderingContext2DTest, NoLayerPromotionWithSharpShadow) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   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(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect
   for (int i = 0;
        i <
        ExpensiveCanvasHeuristicParameters::kExpensiveRecordingStackDepth - 1;
        ++i) {
     Context2d()->save();
     Context2d()->translate(1.0f, 0.0f);
   }
   CanvasElement().FinalizeFrame();  // To close the current frame
 }
 
 TEST_F(CanvasRenderingContext2DTest, FallbackWithLargeState) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillRect(0, 0, 1, 1);  // To have a non-empty dirty rect
   for (int i = 0;
        i < ExpensiveCanvasHeuristicParameters::kExpensiveRecordingStackDepth;
        ++i) {
     Context2d()->save();
     Context2d()->translate(1.0f, 0.0f);
   }
   CanvasElement().FinalizeFrame();  // 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(kOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectFallback),
-          kOpaque, nullptr));
+          kOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillText("Text", 0, 5);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        NonOpaqueDisplayListDoesNotFallBackForText) {
   CreateContext(kNonOpaque);
   std::unique_ptr<RecordingImageBufferSurface> surface =
       WTF::WrapUnique(new RecordingImageBufferSurface(
           IntSize(10, 10),
           MockSurfaceFactory::Create(MockSurfaceFactory::kExpectNoFallback),
-          kNonOpaque, nullptr));
+          kNonOpaque));
   CanvasElement().CreateImageBufferUsingSurfaceForTesting(std::move(surface));
 
   Context2d()->fillText("Text", 0, 5);
 }
 
 TEST_F(CanvasRenderingContext2DTest, ImageResourceLifetime) {
   NonThrowableExceptionState non_throwable_exception_state;
   Element* canvas_element =
       GetDocument().createElement("canvas", non_throwable_exception_state);
   EXPECT_FALSE(non_throwable_exception_state.HadException());
@@ skipping 488 matching lines @@
 
   RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
       experimental_canvas_features_runtime_flag);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
       color_correct_rendering_runtime_flag);
   RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(
       color_correct_rendering_default_mode_runtime_flag);
 }
 
 }  // namespace blink