Implement color-gamut media query

third_party/WebKit/Source/core/css/MediaQueryEvaluator.cpp

 /*
  * CSS Media Query Evaluator
  *
  * Copyright (C) 2006 Kimmo Kinnunen <kimmo.t.kinnunen@nokia.com>.
  * Copyright (C) 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 33 matching lines @@
 #include "core/dom/NodeComputedStyle.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/style/ComputedStyle.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/FloatRect.h"
+#include "platform/graphics/ColorSpace.h"
 #include "public/platform/PointerProperties.h"
 #include "public/platform/ShapeProperties.h"
 #include "public/platform/WebDisplayMode.h"
 #include "wtf/HashMap.h"
 
 namespace blink {
 
 using namespace MediaFeatureNames;
 
 enum MediaFeaturePrefix { MinPrefix, MaxPrefix, NoPrefix };
@@ skipping 682 matching lines @@
 
   if (!value.isID)
     return false;
 
   // If a platform interface supplies progressive/interlace info for TVs in the
   // future, it needs to be handled here. For now, assume a modern TV with
   // progressive display.
   return (value.id == CSSValueProgressive);
 }
 
+static bool colorGamutMediaFeatureEval(const MediaQueryExpValue& value,
+                                       MediaFeaturePrefix,
+                                       const MediaValues& mediaValues) {
+  // isValid() is false if there is no parameter. Without parameter we should
+  // return true to indicate that colorGamutMediaFeature is enabled in the
+  // browser.
+  if (!value.isValid())
+    return true;
+
+  if (!value.isID)
+    return false;
+
+  DCHECK(value.id == CSSValueSRGB || value.id == CSSValueP3 ||
+         value.id == CSSValueRec2020);
+
+  ColorSpaceGamut gamut = mediaValues.colorGamut();
+  switch (gamut) {
+    case ColorSpaceGamut::Unknown:
+    case ColorSpaceGamut::LessThanNTSC:
+    case ColorSpaceGamut::NTSC:
+    case ColorSpaceGamut::SRGB:
+      return value.id == CSSValueSRGB;
+    case ColorSpaceGamut::AlmostP3:
+    case ColorSpaceGamut::P3:
+    case ColorSpaceGamut::AdobeRGB:
+    case ColorSpaceGamut::Wide:
+      return value.id == CSSValueSRGB || value.id == CSSValueP3;
+    case ColorSpaceGamut::BT2020:
+    case ColorSpaceGamut::ProPhoto:
+    case ColorSpaceGamut::UltraWide:
+      return value.id == CSSValueSRGB || value.id == CSSValueP3 ||
+             value.id == CSSValueRec2020;
+    case ColorSpaceGamut::End:

[Yoav Weiss, 2017/01/27 12:13:38]

Potential nit: Can we use `default:` here and avoid one of the returns?

[mlamouri (slow - plz ping), 2017/01/27 16:54:29]

I prefer to avoid `default` so if a new value gets added, it will fail to
compile. Most compilers will understand that all values of the enum are handled
but every time I try one Android or Microsoft compiler is too dumb. Happy to
give it a shot again :)

[hubbe, 2017/01/27 18:19:37]

I think it would be easier to just do something like:

switch (value.id) {
   case CSSValueP3:
       return gamut >= ColorSpaceGamut::P3;
   ....
}

[mlamouri (slow - plz ping), 2017/01/27 18:54:17]

That is true but because `value.id` isn't a "restricted" enum, new values on
either side (color-gamut MQ or ColorSpaceGamut) could be added without this code
being looked at. The primary goal here is making sure we don't forget about this
code :)

+      NOTREACHED();
+      return false;
+  }
+
+  return false;
+}
+
 void MediaQueryEvaluator::init() {
   // Create the table.
   gFunctionMap = new FunctionMap;
 #define ADD_TO_FUNCTIONMAP(name) \
   gFunctionMap->set(name##MediaFeature.impl(), name##MediaFeatureEval);
   CSS_MEDIAQUERY_NAMES_FOR_EACH_MEDIAFEATURE(ADD_TO_FUNCTIONMAP);
 #undef ADD_TO_FUNCTIONMAP
 }
 
 bool MediaQueryEvaluator::eval(const MediaQueryExp* expr) const {
   if (!m_mediaValues || !m_mediaValues->hasValues())
     return true;
 
   DCHECK(gFunctionMap);
 
   // Call the media feature evaluation function. Assume no prefix and let
   // trampoline functions override the prefix if prefix is used.
   EvalFunc func = gFunctionMap->get(expr->mediaFeature().impl());
   if (func)
     return func(expr->expValue(), NoPrefix, *m_mediaValues);
 
   return false;
 }
 
 }  // namespace blink