Add rec-2020 and p3 color spaces to canvas

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 12 matching lines @@
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/html/canvas/CanvasRenderingContext.h"
 
 #include "core/html/canvas/CanvasContextCreationAttributes.h"
 #include "core/html/canvas/CanvasImageSource.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
+const char* const kLegacyCanvasColorSpaceName = "legacy-srgb";
+const char* const kSRGBCanvasColorSpaceName = "srgb";
 const char* const kLinearRGBCanvasColorSpaceName = "linear-rgb";
-const char* const kSRGBCanvasColorSpaceName = "srgb";
-const char* const kLegacyCanvasColorSpaceName = "legacy-srgb";
+const char* const kLinearRec2020CanvasColorSpaceName = "linear-rec-2020";
+const char* const kLinearP3CanvasColorSpaceName = "linear-p3";
 
 namespace blink {
 
 CanvasRenderingContext::CanvasRenderingContext(
     HTMLCanvasElement* canvas,
     OffscreenCanvas* offscreenCanvas,
     const CanvasContextCreationAttributes& attrs)
     : m_canvas(canvas),
       m_offscreenCanvas(offscreenCanvas),
       m_colorSpace(kLegacyCanvasColorSpace),
       m_creationAttributes(attrs) {
   if (RuntimeEnabledFeatures::experimentalCanvasFeaturesEnabled() &&
       RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
     if (m_creationAttributes.colorSpace() == kSRGBCanvasColorSpaceName)
       m_colorSpace = kSRGBCanvasColorSpace;
     else if (m_creationAttributes.colorSpace() ==
              kLinearRGBCanvasColorSpaceName)
       m_colorSpace = kLinearRGBCanvasColorSpace;
+    else if (m_creationAttributes.colorSpace() ==
+             kLinearRec2020CanvasColorSpaceName)
+      m_colorSpace = kLinearRec2020CanvasColorSpace;
+    else if (m_creationAttributes.colorSpace() == kLinearP3CanvasColorSpaceName)
+      m_colorSpace = kLinearP3CanvasColorSpace;
   }
   // 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 kLegacyCanvasColorSpace:
-      return kLegacyCanvasColorSpaceName;
+    case kLinearRec2020CanvasColorSpace:
+      return kLinearRec2020CanvasColorSpaceName;
+    case kLinearP3CanvasColorSpace:
+      return kLinearP3CanvasColorSpaceName;
   };
   CHECK(false);
   return "";
 }
 
 sk_sp<SkColorSpace> CanvasRenderingContext::skColorSpace() 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 kLegacyCanvasColorSpace:
-      if (RuntimeEnabledFeatures::colorCorrectRenderingEnabled()) {
-        // 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);
-      }
-      return nullptr;
+    case kLinearRec2020CanvasColorSpace: {
+      // 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 kLinearP3CanvasColorSpace: {
+      // 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;
 }
 
 ColorBehavior CanvasRenderingContext::colorBehaviorForMediaDrawnToCanvas()
     const {
   sk_sp<SkColorSpace> colorSpace = skColorSpace();
   if (colorSpace) {
     return ColorBehavior::transformTo(std::move(colorSpace));
   }
   return ColorBehavior::transformToGlobalTarget();
 }
 
 SkColorType CanvasRenderingContext::colorType() const {
   switch (m_colorSpace) {
     case kLinearRGBCanvasColorSpace:
+    case kLinearRec2020CanvasColorSpace:
+    case kLinearP3CanvasColorSpace:
       return kRGBA_F16_SkColorType;
     default:
       return kN32_SkColorType;
   }
 }
 
 void CanvasRenderingContext::dispose() {
   // HTMLCanvasElement and CanvasRenderingContext have a circular reference.
   // When the pair is no longer reachable, their destruction order is non-
   // deterministic, so the first of the two to be destroyed needs to notify
@@ skipping 63 matching lines @@
   }
   return taintOrigin;
 }
 
 DEFINE_TRACE(CanvasRenderingContext) {
   visitor->trace(m_canvas);
   visitor->trace(m_offscreenCanvas);
 }
 
 }  // namespace blink