color: Add ColorCanvasExtensions runtime flag

third_party/WebKit/Source/core/frame/ImageBitmapTest.cpp

 /*
  * Copyright (c) 2013, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 57 matching lines @@
 
     // Save the global memory cache to restore it upon teardown.
     global_memory_cache_ = ReplaceMemoryCacheForTesting(MemoryCache::Create());
 
     // Save the state of experimental canvas features and color correct
     // rendering flags to restore them on teardown.
     experimental_canvas_features =
         RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled();
     color_correct_rendering =
         RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
-    color_correct_rendering_default_mode =
-        RuntimeEnabledFeatures::colorCorrectRenderingDefaultModeEnabled();
+    color_canvas_extensions =
+        RuntimeEnabledFeatures::colorCanvasExtensionsEnabled();
   }
   virtual void TearDown() {
     // Garbage collection is required prior to switching out the
     // test's memory cache; image resources are released, evicting
     // them from the cache.
     ThreadState::Current()->CollectGarbage(BlinkGC::kNoHeapPointersOnStack,
                                            BlinkGC::kGCWithSweep,
                                            BlinkGC::kForcedGC);
 
     ReplaceMemoryCacheForTesting(global_memory_cache_.Release());
     RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
         experimental_canvas_features);
     RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
         color_correct_rendering);
-    RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(
-        color_correct_rendering_default_mode);
+    RuntimeEnabledFeatures::setColorCanvasExtensionsEnabled(
+        color_canvas_extensions);
   }
 
   sk_sp<SkImage> image_, image2_;
   Persistent<MemoryCache> global_memory_cache_;
   bool experimental_canvas_features;
   bool color_correct_rendering;
-  bool color_correct_rendering_default_mode;
+  bool color_canvas_extensions;
 };
 
 TEST_F(ImageBitmapTest, ImageResourceConsistency) {
+  RuntimeEnabledFeatures::setColorCanvasExtensionsEnabled(true);
   const ImageBitmapOptions default_options;
   HTMLImageElement* image_element =
       HTMLImageElement::Create(*Document::Create());
   ImageResourceContent* image = ImageResourceContent::CreateLoaded(
       StaticBitmapImage::Create(image_).Get());
   image_element->SetImageForTest(image);
 
   Optional<IntRect> crop_rect =
       IntRect(0, 0, image_->width(), image_->height());
   ImageBitmap* image_bitmap_no_crop =
@@ skipping 24 matching lines @@
 
   RefPtr<StaticBitmapImage> empty_image =
       image_bitmap_outside_crop->BitmapImage();
   ASSERT_NE(empty_image->ImageForCurrentFrame(),
             image_element->CachedImage()->GetImage()->ImageForCurrentFrame());
 }
 
 // Verifies that ImageBitmaps constructed from HTMLImageElements hold a
 // reference to the original Image if the HTMLImageElement src is changed.
 TEST_F(ImageBitmapTest, ImageBitmapSourceChanged) {
+  RuntimeEnabledFeatures::setColorCanvasExtensionsEnabled(true);
   HTMLImageElement* image = HTMLImageElement::Create(*Document::Create());
   ImageResourceContent* original_image_resource =
       ImageResourceContent::CreateLoaded(
           StaticBitmapImage::Create(image_).Get());
   image->SetImageForTest(original_image_resource);
 
   const ImageBitmapOptions default_options;
   Optional<IntRect> crop_rect =
       IntRect(0, 0, image_->width(), image_->height());
   ImageBitmap* image_bitmap = ImageBitmap::Create(
@@ skipping 50 matching lines @@
   static const Vector<String> kConversions = {
       "none", "default", "default", "srgb", "linear-rgb", "p3", "rec2020"};
   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(ImageBitmapTest, ImageBitmapColorSpaceConversionHTMLImageElement) {
   HTMLImageElement* image_element =
       HTMLImageElement::Create(*Document::Create());
 
   SkPaint p;
   p.setColor(SK_ColorRED);
@@ skipping 377 matching lines @@
     color_space_xform->apply(color_format, transformed_pixel.get(),
                              color_format32, src_pixel.get(), 1,
                              SkAlphaType::kUnpremul_SkAlphaType);
     int compare = std::memcmp(converted_pixel.get(), transformed_pixel.get(),
                               image_info.bytesPerPixel());
     ASSERT_EQ(compare, 0);
   }
 }
 
 }  // namespace blink