color: Add ColorCanvasExtensions runtime flag

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/V8BindingForCore.h"
 #include "bindings/core/v8/V8BindingForTesting.h"
 #include "core/dom/Document.h"
@@ skipping 25 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColorSpaceXform.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/core/SkSwizzle.h"
 
 using ::testing::Mock;
 
 namespace blink {
 
-namespace {
-
-gfx::ColorSpace AdobeRGBColorSpace() {
-  return gfx::ColorSpace(gfx::ColorSpace::PrimaryID::ADOBE_RGB,
-                         gfx::ColorSpace::TransferID::GAMMA22);
-}
-
-}  // namespace
-
 enum BitmapOpacity { kOpaqueBitmap, kTransparentBitmap };
 
 class FakeImageSource : public CanvasImageSource {
  public:
   FakeImageSource(IntSize, BitmapOpacity);
 
   PassRefPtr<Image> GetSourceImageForCanvas(SourceImageStatus*,
                                             AccelerationHint,
                                             SnapshotReason,
                                             const FloatSize&) override;
@@ skipping 998 matching lines @@
   CanvasElement().GetImageBuffer()->DisableAcceleration();
   EXPECT_FALSE(CanvasElement().GetImageBuffer()->IsAccelerated());
 
   context->fillRect(10, 10, 100, 100);
 
   EXPECT_EQ(0, GetCurrentGPUMemoryUsage());
   EXPECT_EQ(0, GetGlobalGPUMemoryUsage());
   EXPECT_EQ(0u, GetGlobalAcceleratedImageBufferCount());
 }
 
-TEST_F(CanvasRenderingContext2DTest,
-       LegacyColorSpaceUsesGlobalTargetColorBehavior) {
-  // Set the global target color space to something distinctly recognizable (not
-  // srgb)
-  gfx::ColorSpace saved_global_target_color_space =
-      ColorBehavior::GlobalTargetColorSpace();
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
-  bool saved_color_correct_rendering_enabled =
-      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
-
-  RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(false);
-  CreateContext(kNonOpaque, "legacy-srgb");
-  ColorBehavior behavior = Context2d()->DrawImageColorBehavior();
-  EXPECT_TRUE(behavior.IsTransformToTargetColorSpace());
-  EXPECT_TRUE(ColorBehavior::GlobalTargetColorSpace() ==
-              behavior.TargetColorSpace());
-
-  // Restore global state to avoid interfering with other tests
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(
-      saved_global_target_color_space);
-  RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
-      saved_color_correct_rendering_enabled);
-}
-
-TEST_F(CanvasRenderingContext2DTest,
-       LegacyColorSpaceUsesSRGBWhenColorCorrectRenderingEnabled) {
-  // Set the global target color space to something distinctly recognizable (not
-  // srgb)
-  gfx::ColorSpace saved_global_target_color_space =
-      ColorBehavior::GlobalTargetColorSpace();
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
-  bool saved_color_correct_rendering_enabled =
-      RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
-
-  RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(true);
-  CreateContext(kNonOpaque, "legacy-srgb");
-  ColorBehavior behavior = Context2d()->DrawImageColorBehavior();
-  EXPECT_TRUE(behavior.IsTransformToTargetColorSpace());
-  EXPECT_TRUE(gfx::ColorSpace::CreateSRGB() == behavior.TargetColorSpace());
-
-  // Restore global state to avoid interfering with other tests
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(
-      saved_global_target_color_space);
-  RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
-      saved_color_correct_rendering_enabled);
-}
-
-TEST_F(CanvasRenderingContext2DTest,
-       SRGBColorSpaceUsesTransformToSRGBColorBehavior) {
-  // Set the global target color space to something distinctly recognizable (not
-  // srgb)
-  gfx::ColorSpace saved_global_target_color_space =
-      ColorBehavior::GlobalTargetColorSpace();
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
-
-  CreateContext(kNonOpaque, "srgb");
-  ColorBehavior behavior = Context2d()->DrawImageColorBehavior();
-  EXPECT_TRUE(behavior.IsTransformToTargetColorSpace());
-  EXPECT_TRUE(gfx::ColorSpace::CreateSRGB() == behavior.TargetColorSpace());
-
-  // Restore global state to avoid interfering with other tests
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(
-      saved_global_target_color_space);
-}
-
-TEST_F(CanvasRenderingContext2DTest,
-       LinearRGBColorSpaceUsesTransformToLinearSRGBColorBehavior) {
-  // Set the global target color space to something distinctly recognizable (not
-  // srgb)
-  gfx::ColorSpace saved_global_target_color_space =
-      ColorBehavior::GlobalTargetColorSpace();
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
-
-  CreateContext(kNonOpaque, "srgb", kLinearPixelMathEnabled);
-  ColorBehavior behavior = Context2d()->DrawImageColorBehavior();
-  EXPECT_TRUE(behavior.IsTransformToTargetColorSpace());
-  EXPECT_TRUE(gfx::ColorSpace::CreateSCRGBLinear() ==
-              behavior.TargetColorSpace());
-
-  // Restore global state to avoid interfering with other tests
-  ColorBehavior::SetGlobalTargetColorSpaceForTesting(
-      saved_global_target_color_space);
-}
-
 enum class ColorSpaceConversion : uint8_t {
   NONE = 0,
   DEFAULT_NOT_COLOR_CORRECTED = 1,
   DEFAULT_COLOR_CORRECTED = 2,
   SRGB = 3,
   LINEAR_RGB = 4,
 
   LAST = LINEAR_RGB
 };
 
 static ImageBitmapOptions PrepareBitmapOptionsAndSetRuntimeFlags(
     const ColorSpaceConversion& color_space_conversion) {
   // Set the color space conversion in ImageBitmapOptions
   ImageBitmapOptions options;
   static const Vector<String> kConversions = {"none", "default", "default",
                                               "srgb", "linear-rgb"};
   options.setColorSpaceConversion(
       kConversions[static_cast<uint8_t>(color_space_conversion)]);
 
   // Set the runtime flags
   bool flag = (color_space_conversion !=
                ColorSpaceConversion::DEFAULT_NOT_COLOR_CORRECTED);
   RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(true);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(flag);
-  RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(!flag);
-
+  RuntimeEnabledFeatures::setColorCanvasExtensionsEnabled(true);
   return options;
 }
 
 TEST_F(CanvasRenderingContext2DTest, ImageBitmapColorSpaceConversion) {
   bool experimental_canvas_features_runtime_flag =
       RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
   bool color_correct_rendering_runtime_flag =
       RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
-  bool color_correct_rendering_default_mode_runtime_flag =
-      RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled();
+  bool color_canvas_extensions_flag =
+      RuntimeEnabledFeatures::colorCanvasExtensionsEnabled();
 
   Persistent<HTMLCanvasElement> canvas =
       Persistent<HTMLCanvasElement>(CanvasElement());
   CanvasContextCreationAttributes attributes;
   attributes.setAlpha(true);
   attributes.setColorSpace("srgb");
   CanvasRenderingContext2D* context = static_cast<CanvasRenderingContext2D*>(
       canvas->GetCanvasRenderingContext("2d", attributes));
   StringOrCanvasGradientOrCanvasPattern fill_style;
   fill_style.setString("#FF0000");
@@ skipping 70 matching lines @@
 
     int compare = std::memcmp(converted_pixel.get(), transformed_pixel.get(),
                               image_info.bytesPerPixel());
     ASSERT_EQ(compare, 0);
   }
 
   RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
       experimental_canvas_features_runtime_flag);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
       color_correct_rendering_runtime_flag);
-  RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(
-      color_correct_rendering_default_mode_runtime_flag);
+  RuntimeEnabledFeatures::setColorCanvasExtensionsEnabled(
+      color_canvas_extensions_flag);
 }
 
 bool ConvertPixelsToColorSpaceAndPixelFormatForTest(
     DOMArrayBufferView* data_array,
     CanvasColorSpace src_color_space,
     CanvasColorSpace dst_color_space,
     CanvasPixelFormat dst_pixel_format,
     std::unique_ptr<uint8_t[]>& converted_pixels) {
   // Setting SkColorSpaceXform::apply parameters
   SkColorSpaceXform::ColorFormat src_color_format =
@@ skipping 80 matching lines @@
 // This test verifies the correct behavior of putImageData member function in
 // color managed mode.
 void TestPutImageDataOnCanvasWithColorSpaceSettings(
     HTMLCanvasElement& canvas_element,
     CanvasColorSpaceSettings canvas_colorspace_setting,
     float color_tolerance) {
   bool experimental_canvas_features_runtime_flag =
       RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
   bool color_correct_rendering_runtime_flag =
       RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
+  bool color_canvas_extensions_flag =
+      RuntimeEnabledFeatures::colorCanvasExtensionsEnabled();
   RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(true);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(true);
+  RuntimeEnabledFeatures::setColorCanvasExtensionsEnabled(true);
 
   bool test_passed = true;
   unsigned num_image_data_color_spaces = 3;
   CanvasColorSpace image_data_color_spaces[] = {
       kSRGBCanvasColorSpace, kRec2020CanvasColorSpace, kP3CanvasColorSpace,
   };
 
   unsigned num_image_data_storage_formats = 3;
   ImageDataStorageFormat image_data_storage_formats[] = {
       kUint8ClampedArrayStorageFormat, kUint16ArrayStorageFormat,
@@ skipping 142 matching lines @@
       }
     }
   }
   delete[] u16_pixels;
   delete[] f32_pixels;
 
   RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
       experimental_canvas_features_runtime_flag);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
       color_correct_rendering_runtime_flag);
+  RuntimeEnabledFeatures::setColorCanvasExtensionsEnabled(
+      color_canvas_extensions_flag);
 }
 
 TEST_F(CanvasRenderingContext2DTest, ColorManagedPutImageDataOnSRGBCanvas) {
   TestPutImageDataOnCanvasWithColorSpaceSettings(
       CanvasElement(), CanvasColorSpaceSettings::CANVAS_SRGB, 0);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        ColorManagedPutImageDataOnLinearSRGBCanvas) {
   TestPutImageDataOnCanvasWithColorSpaceSettings(
@@ skipping 80 matching lines @@
 
   // Wake up again, which should request a compositing update synchronously.
   GetDocument().GetPage()->SetVisibilityState(kPageVisibilityStateVisible,
                                               false);
   EXPECT_EQ(!!CANVAS2D_HIBERNATION_ENABLED,
             layer->NeedsCompositingInputsUpdate());
   RunUntilIdle();  // Clear task queue.
 }
 
 }  // namespace blink