Use gfx::ColorSpace instead of SkColorSpace in Blink

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/frame/FrameView.h"
 #include "core/frame/ImageBitmap.h"
 #include "core/html/HTMLCanvasElement.h"
@@ skipping 17 matching lines @@
 #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 "wtf/PtrUtil.h"
 #include <memory>
 
 using ::testing::Mock;
 
 namespace blink {
 
+namespace {
+
+gfx::ColorSpace AdobeRGBColorSpace() {
+  return gfx::ColorSpace(gfx::ColorSpace::PrimaryID::ADOBE_RGB,
+                         gfx::ColorSpace::TransferID::GAMMA22);
+}
+
+}  // namespace
+
 enum BitmapOpacity { OpaqueBitmap, TransparentBitmap };
 
 class FakeImageSource : public CanvasImageSource {
  public:
   FakeImageSource(IntSize, BitmapOpacity);
 
   PassRefPtr<Image> getSourceImageForCanvas(SourceImageStatus*,
                                             AccelerationHint,
                                             SnapshotReason,
                                             const FloatSize&) const override;
@@ skipping 160 matching lines @@
 void CanvasRenderingContext2DTest::TearDown() {
   ThreadState::current()->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, nullptr,
-                                          kN32_SkColorType));
+  return adoptRef(new Canvas2DLayerBridge(
+      std::move(provider), size, 0, NonOpaque, accelerationMode,
+      gfx::ColorSpace::CreateSRGB(), false, kN32_SkColorType));
 }
 
 //============================================================================
 
 class FakeAcceleratedImageBufferSurfaceForTesting
     : public UnacceleratedImageBufferSurface {
  public:
   FakeAcceleratedImageBufferSurfaceForTesting(const IntSize& size,
                                               OpacityMode mode)
       : UnacceleratedImageBufferSurface(size, mode), m_isAccelerated(true) {}
@@ skipping 904 matching lines @@
 
   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)
-  sk_sp<SkColorSpace> savedGlobalTargetColorSpace =
+  gfx::ColorSpace savedGlobalTargetColorSpace =
       ColorBehavior::globalTargetColorSpace();
-  ColorBehavior::setGlobalTargetColorSpaceForTesting(
-      SkColorSpace::MakeNamed(SkColorSpace::kAdobeRGB_Named));
+  ColorBehavior::setGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
   bool savedColorCorrectRenderingEnabled =
       RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
 
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(false);
   createContext(NonOpaque, "legacy-srgb");
   ColorBehavior behavior = context2d()->drawImageColorBehavior();
   EXPECT_TRUE(behavior.isTransformToTargetColorSpace());
-  EXPECT_TRUE(
-      SkColorSpace::Equals(ColorBehavior::globalTargetColorSpace().get(),
-                           behavior.targetColorSpace().get()));
+  EXPECT_TRUE(ColorBehavior::globalTargetColorSpace() ==
+              behavior.targetColorSpace());
 
   // Restore global state to avoid interfering with other tests
   ColorBehavior::setGlobalTargetColorSpaceForTesting(
       savedGlobalTargetColorSpace);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
       savedColorCorrectRenderingEnabled);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        LegacyColorSpaceUsesSRGBWhenColorCorrectRenderingEnabled) {
   // Set the global target color space to something distinctly recognizable (not
   // srgb)
-  sk_sp<SkColorSpace> savedGlobalTargetColorSpace =
+  gfx::ColorSpace savedGlobalTargetColorSpace =
       ColorBehavior::globalTargetColorSpace();
-  ColorBehavior::setGlobalTargetColorSpaceForTesting(
-      SkColorSpace::MakeNamed(SkColorSpace::kAdobeRGB_Named));
+  ColorBehavior::setGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
   bool savedColorCorrectRenderingEnabled =
       RuntimeEnabledFeatures::colorCorrectRenderingEnabled();
 
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(true);
   createContext(NonOpaque, "legacy-srgb");
   ColorBehavior behavior = context2d()->drawImageColorBehavior();
-  sk_sp<SkColorSpace> srgbColorSpace =
-      SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
   EXPECT_TRUE(behavior.isTransformToTargetColorSpace());
-  EXPECT_TRUE(SkColorSpace::Equals(srgbColorSpace.get(),
-                                   behavior.targetColorSpace().get()));
+  EXPECT_TRUE(gfx::ColorSpace::CreateSRGB() == behavior.targetColorSpace());
 
   // Restore global state to avoid interfering with other tests
   ColorBehavior::setGlobalTargetColorSpaceForTesting(
       savedGlobalTargetColorSpace);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
       savedColorCorrectRenderingEnabled);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        SRGBColorSpaceUsesTransformToSRGBColorBehavior) {
   // Set the global target color space to something distinctly recognizable (not
   // srgb)
-  sk_sp<SkColorSpace> savedGlobalTargetColorSpace =
+  gfx::ColorSpace savedGlobalTargetColorSpace =
       ColorBehavior::globalTargetColorSpace();
-  ColorBehavior::setGlobalTargetColorSpaceForTesting(
-      SkColorSpace::MakeNamed(SkColorSpace::kAdobeRGB_Named));
+  ColorBehavior::setGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
 
   createContext(NonOpaque, "srgb");
   ColorBehavior behavior = context2d()->drawImageColorBehavior();
-  sk_sp<SkColorSpace> srgbColorSpace =
-      SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
   EXPECT_TRUE(behavior.isTransformToTargetColorSpace());
-  EXPECT_TRUE(SkColorSpace::Equals(srgbColorSpace.get(),
-                                   behavior.targetColorSpace().get()));
+  EXPECT_TRUE(gfx::ColorSpace::CreateSRGB() == behavior.targetColorSpace());
 
   // Restore global state to avoid interfering with other tests
   ColorBehavior::setGlobalTargetColorSpaceForTesting(
       savedGlobalTargetColorSpace);
 }
 
 TEST_F(CanvasRenderingContext2DTest,
        LinearRGBColorSpaceUsesTransformToLinearSRGBColorBehavior) {
   // Set the global target color space to something distinctly recognizable (not
   // srgb)
-  sk_sp<SkColorSpace> savedGlobalTargetColorSpace =
+  gfx::ColorSpace savedGlobalTargetColorSpace =
       ColorBehavior::globalTargetColorSpace();
-  ColorBehavior::setGlobalTargetColorSpaceForTesting(
-      SkColorSpace::MakeNamed(SkColorSpace::kAdobeRGB_Named));
+  ColorBehavior::setGlobalTargetColorSpaceForTesting(AdobeRGBColorSpace());
 
   createContext(NonOpaque, "linear-rgb");
   ColorBehavior behavior = context2d()->drawImageColorBehavior();
-  sk_sp<SkColorSpace> linearSrgbColorSpace =
-      SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named);
   EXPECT_TRUE(behavior.isTransformToTargetColorSpace());
-  EXPECT_TRUE(SkColorSpace::Equals(linearSrgbColorSpace.get(),
-                                   behavior.targetColorSpace().get()));
+  EXPECT_TRUE(gfx::ColorSpace::CreateSCRGBLinear() ==
+              behavior.targetColorSpace());
 
   // Restore global state to avoid interfering with other tests
   ColorBehavior::setGlobalTargetColorSpaceForTesting(
       savedGlobalTargetColorSpace);
 }
 
 enum class ColorSpaceConversion : uint8_t {
   NONE = 0,
   DEFAULT_NOT_COLOR_CORRECTED = 1,
   DEFAULT_COLOR_CORRECTED = 2,
@@ skipping 75 matching lines @@
     SkImage* convertedImage =
         imageBitmap->bitmapImage()
             ->imageForCurrentFrame(ColorBehavior::ignore())
             .get();
 
     switch (colorSpaceConversion) {
       case ColorSpaceConversion::NONE:
         NOTREACHED();
         break;
       case ColorSpaceConversion::DEFAULT_NOT_COLOR_CORRECTED:
-        colorSpace = ColorBehavior::globalTargetColorSpace();
+        colorSpace = ColorBehavior::globalTargetColorSpace().ToSkColorSpace();
         colorFormat = colorFormat32;
         break;
       case ColorSpaceConversion::DEFAULT_COLOR_CORRECTED:
       case ColorSpaceConversion::SRGB:
         colorSpace = SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
         colorFormat = colorFormat32;
         break;
       case ColorSpaceConversion::LINEAR_RGB:
         colorSpace = SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named);
         colorType = SkColorType::kRGBA_F16_SkColorType;
@@ skipping 27 matching lines @@
 
   RuntimeEnabledFeatures::setExperimentalCanvasFeaturesEnabled(
       experimentalCanvasFeaturesRuntimeFlag);
   RuntimeEnabledFeatures::setColorCorrectRenderingEnabled(
       colorCorrectRenderingRuntimeFlag);
   RuntimeEnabledFeatures::setColorCorrectRenderingDefaultModeEnabled(
       colorCorrectRenderingDefaultModeRuntimeFlag);
 }
 
 }  // namespace blink