Use gfx::ColorSpace instead of SkColorSpace in Blink

third_party/WebKit/Source/core/html/canvas/CanvasRenderingContext.cpp

 /*
  * Copyright (C) 2009 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 27 matching lines @@
 
 namespace blink {
 
 CanvasRenderingContext::CanvasRenderingContext(
     HTMLCanvasElement* canvas,
     OffscreenCanvas* offscreenCanvas,
     const CanvasContextCreationAttributes& attrs)
     : m_canvas(canvas),
       m_offscreenCanvas(offscreenCanvas),
       m_colorSpace(kLegacyCanvasColorSpace),
+      m_gfxColorSpace(gfx::ColorSpace::CreateSRGB()),
       m_creationAttributes(attrs) {
   if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
       RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
-    if (m_creationAttributes.colorSpace() == kSRGBCanvasColorSpaceName)
+    if (m_creationAttributes.colorSpace() == kSRGBCanvasColorSpaceName) {
       m_colorSpace = kSRGBCanvasColorSpace;
-    else if (m_creationAttributes.colorSpace() ==
-             kLinearRGBCanvasColorSpaceName)
+    } else if (m_creationAttributes.colorSpace() ==
+               kLinearRGBCanvasColorSpaceName) {
       m_colorSpace = kLinearRGBCanvasColorSpace;
-    else if (m_creationAttributes.colorSpace() == kRec2020CanvasColorSpaceName)
+      m_gfxColorSpace = gfx::ColorSpace::CreateSCRGBLinear();
+    } else if (m_creationAttributes.colorSpace() ==
+               kRec2020CanvasColorSpaceName) {
       m_colorSpace = kRec2020CanvasColorSpace;
-    else if (m_creationAttributes.colorSpace() == kP3CanvasColorSpaceName)
+      m_gfxColorSpace = gfx::ColorSpace(
+          gfx::ColorSpace::PrimaryID::BT2020,
+          gfx::ColorSpace::TransferID::IEC61966_2_1,
+          gfx::ColorSpace::MatrixID::RGB, gfx::ColorSpace::RangeID::FULL);
+    } else if (m_creationAttributes.colorSpace() == kP3CanvasColorSpaceName) {
       m_colorSpace = kP3CanvasColorSpace;
+      m_gfxColorSpace = gfx::ColorSpace(

[Justin Novosad, 2017/01/31 00:15:58]

I am a bit concerned about having this duplication between m_colorSpace and
m_gfxColorSpace. Would be a more maintainable design to have a single ground
truth, like we had before this change where the skColorSpace() method was
generating SkColorSpaces on the fly.  If you are concerned about the overhead of
creating gfx::ColorSpace, we could use lazily initialized static instances, but
I don't think that is necessary.

[ccameron, 2017/01/31 05:34:26]

Yeah, that was unnecessary optimization. Got rid of it.

+          gfx::ColorSpace::PrimaryID::SMPTEST432_1,
+          gfx::ColorSpace::TransferID::IEC61966_2_1,
+          gfx::ColorSpace::MatrixID::RGB, gfx::ColorSpace::RangeID::FULL);
+    }
   }
   // Make m_creationAttributes reflect the effective colorSpace rather than the
   // requested one
   m_creationAttributes.setColorSpace(colorSpaceAsString());
 }
 
 WTF::String CanvasRenderingContext::colorSpaceAsString() const {
   switch (m_colorSpace) {
     case kLegacyCanvasColorSpace:
       return kLegacyCanvasColorSpaceName;
     case kSRGBCanvasColorSpace:
       return kSRGBCanvasColorSpaceName;
     case kLinearRGBCanvasColorSpace:
       return kLinearRGBCanvasColorSpaceName;
     case kRec2020CanvasColorSpace:
       return kRec2020CanvasColorSpaceName;
     case kP3CanvasColorSpace:
       return kP3CanvasColorSpaceName;
   };
   CHECK(false);
   return "";
 }
 
-sk_sp<SkColorSpace> CanvasRenderingContext::skColorSpace() const {
+sk_sp<SkColorSpace> CanvasRenderingContext::skSurfaceColorSpace() const {
   if (!RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() ||
       !RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
     return nullptr;
   }
-  switch (m_colorSpace) {
-    case kLegacyCanvasColorSpace:
-      // Legacy colorspace ensures color matching with CSS is preserved.
-      // So if CSS is color corrected from sRGB to display space, then
-      // canvas must do the same
-      return SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
-    case kSRGBCanvasColorSpace:
-      return SkColorSpace::MakeNamed(SkColorSpace::kSRGB_Named);
-    case kLinearRGBCanvasColorSpace:
-      return SkColorSpace::MakeNamed(SkColorSpace::kSRGBLinear_Named);
-    case kRec2020CanvasColorSpace: {
-      // TODO(zakerinasab): Replace this with proper constructor from Skia
-      // when it is provided.
-      // https://en.wikipedia.org/wiki/Rec._2020
-      SkColorSpacePrimaries kPrimaries = {0.708, 0.292, 0.170,  0.797,
-                                          0.131, 0.046, 0.3127, 0.3290};
-      SkMatrix44 kToXYZD50;
-      if (!kPrimaries.toXYZD50(&kToXYZD50))
-        return nullptr;
-      return SkColorSpace::MakeRGB(
-          SkColorSpace::RenderTargetGamma::kLinear_RenderTargetGamma,
-          kToXYZD50);
-    }
-    case kP3CanvasColorSpace: {
-      // TODO(zakerinasab): Replace this with proper constructor from Skia
-      // when it is provided.
-      // https://en.wikipedia.org/wiki/DCI-P3
-      SkColorSpacePrimaries kPrimaries = {0.680, 0.320, 0.265,  0.690,
-                                          0.150, 0.060, 0.3127, 0.3290};
-      SkMatrix44 kToXYZD50;
-      if (!kPrimaries.toXYZD50(&kToXYZD50))
-        return nullptr;
-      return SkColorSpace::MakeRGB(
-          SkColorSpace::RenderTargetGamma::kLinear_RenderTargetGamma,
-          kToXYZD50);
-    }
-  };
-  CHECK(false);
-  return nullptr;
+  return m_gfxColorSpace.ToSkColorSpace();
 }
 
 ColorBehavior CanvasRenderingContext::colorBehaviorForMediaDrawnToCanvas()
     const {
-  sk_sp<SkColorSpace> colorSpace = skColorSpace();
-  if (colorSpace) {
-    return ColorBehavior::transformTo(std::move(colorSpace));
+  if (!RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() ||
+      !RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
+    return ColorBehavior::transformToGlobalTarget();
   }
-  return ColorBehavior::transformToGlobalTarget();
+  return ColorBehavior::transformTo(m_gfxColorSpace);
 }
 
 SkColorType CanvasRenderingContext::colorType() const {
   switch (m_colorSpace) {
     case kLinearRGBCanvasColorSpace:
     case kRec2020CanvasColorSpace:
     case kP3CanvasColorSpace:
       return kRGBA_F16_SkColorType;
     default:
       return kN32_SkColorType;
@@ skipping 70 matching lines @@
   }
   return taintOrigin;
 }
 
 DEFINE_TRACE(CanvasRenderingContext) {
   visitor->trace(m_canvas);
   visitor->trace(m_offscreenCanvas);
 }
 
 }  // namespace blink