[MQ4] Add schemas for resolution and -webkit-device-pixel-ratio features

https://bugs.webkit.org/show_bug.cgi?id=247118 rdar://101625468 Reviewed by Alan Baradlay. * Source/WTF/wtf/text/StringOperators.h: (WTF::StringAppend::operator AtomString const): AtomString(String) is explicit. * Source/WebCore/css/query/GenericMediaQueryEvaluator.cpp: (WebCore::MQ::evaluateResolutionComparison): (WebCore::MQ::evaluateResolutionFeature): * Source/WebCore/css/query/GenericMediaQueryEvaluator.h: * Source/WebCore/css/query/GenericMediaQueryParser.cpp: (WebCore::MQ::GenericMediaQueryParserBase::consumeBooleanOrPlainFeature): Support -webkit-min-/-webkit-max- prefixes. (WebCore::MQ::GenericMediaQueryParserBase::consumeValue): Consume resolution values. * Source/WebCore/css/query/MediaQueryFeatures.cpp: (WebCore::MQ::Features::NumberSchema::NumberSchema): (WebCore::MQ::Features::NumberSchema::valueFunction): (WebCore::MQ::Features::ResolutionSchema::ResolutionSchema): (WebCore::MQ::Features::ResolutionSchema::valueFunction): (WebCore::MQ::Features::deviceScaleFactor): (WebCore::MQ::Features::devicePixelRatio): (WebCore::MQ::Features::resolution): Add schemas and evaluation functions. Canonical link: https://commits.webkit.org/256064@main
WebKit · Oct 27, 2022 · b0723e9 · b0723e9
1 parent 5cfc81b
commit b0723e9
Show file tree

Hide file tree

Showing 5 changed files with 106 additions and 5 deletions.
diff --git a/Source/WTF/wtf/text/StringOperators.h b/Source/WTF/wtf/text/StringOperators.h
@@ -43,7 +43,7 @@ template<typename StringType1, typename StringType2> class StringAppend {
 
     operator AtomString() const
     {
-        return operator String();
+        return AtomString(operator String());
     }
 
     bool is8Bit()

diff --git a/Source/WebCore/css/query/GenericMediaQueryEvaluator.cpp b/Source/WebCore/css/query/GenericMediaQueryEvaluator.cpp
@@ -109,6 +109,19 @@ static EvaluationResult evaluateIntegerComparison(int number, const std::optiona
     return toEvaluationResult(compare(comparison->op, left, right));
 };
 
+static EvaluationResult evaluateResolutionComparison(double resolution, const std::optional<Comparison>& comparison, Side side)
+{
+    if (!comparison)
+        return EvaluationResult::True;
+
+    auto expressionResolution = dynamicDowncast<CSSPrimitiveValue>(comparison->value.get())->doubleValue(CSSUnitType::CSS_DPPX);
+
+    auto left = side == Side::Left ? expressionResolution : resolution;
+    auto right = side == Side::Left ? resolution : expressionResolution;
+
+    return toEvaluationResult(compare(comparison->op, left, right));
+};
+
 EvaluationResult evaluateLengthFeature(const Feature& feature, LayoutUnit length, const CSSToLengthConversionData& conversionData)
 {
     if (!feature.leftComparison && !feature.rightComparison)
@@ -193,6 +206,17 @@ EvaluationResult evaluateNumberFeature(const Feature& feature, double currentVal
     return leftResult & rightResult;
 }
 
+EvaluationResult evaluateResolutionFeature(const Feature& feature, double currentValue)
+{
+    if (!feature.leftComparison && !feature.rightComparison)
+        return toEvaluationResult(!!currentValue);
+
+    auto leftResult = evaluateResolutionComparison(currentValue, feature.leftComparison, Side::Left);
+    auto rightResult = evaluateResolutionComparison(currentValue, feature.rightComparison, Side::Right);
+
+    return leftResult & rightResult;
+}
+
 EvaluationResult evaluateIdentifierFeature(const Feature& feature, CSSValueID currentValue)
 {
     if (!feature.rightComparison)

diff --git a/Source/WebCore/css/query/GenericMediaQueryEvaluator.h b/Source/WebCore/css/query/GenericMediaQueryEvaluator.h
@@ -40,6 +40,7 @@ EvaluationResult evaluateRatioFeature(const Feature&, double);
 EvaluationResult evaluateBooleanFeature(const Feature&, bool);
 EvaluationResult evaluateIntegerFeature(const Feature&, int);
 EvaluationResult evaluateNumberFeature(const Feature&, double);
+EvaluationResult evaluateResolutionFeature(const Feature&, double);
 EvaluationResult evaluateIdentifierFeature(const Feature&, CSSValueID);
 
 template<typename ConcreteEvaluator>

diff --git a/Source/WebCore/css/query/GenericMediaQueryParser.cpp b/Source/WebCore/css/query/GenericMediaQueryParser.cpp
@@ -58,6 +58,10 @@ std::optional<Feature> GenericMediaQueryParserBase::consumeBooleanOrPlainFeature
             return { StringView(name).substring(4).toAtomString(), ComparisonOperator::GreaterThanOrEqual };
         if (name.startsWith("max-"_s))
             return { StringView(name).substring(4).toAtomString(), ComparisonOperator::LessThanOrEqual };
+        if (name.startsWith("-webkit-min-"_s))
+            return { "-webkit-"_s + StringView(name).substring(12), ComparisonOperator::GreaterThanOrEqual };
+        if (name.startsWith("-webkit-max-"_s))
+            return { "-webkit-"_s + StringView(name).substring(12), ComparisonOperator::LessThanOrEqual };
 
         return { name, ComparisonOperator::Equal };
     };
@@ -194,6 +198,9 @@ RefPtr<CSSValue> GenericMediaQueryParserBase::consumeValue(CSSParserTokenRange&
         return value;
     if (auto value = CSSPropertyParserHelpers::consumeAspectRatioValue(range))
         return value;
+    if (auto value = CSSPropertyParserHelpers::consumeResolution(range))
+        return value;
+
     return nullptr;
 }
 

diff --git a/Source/WebCore/css/query/MediaQueryFeatures.cpp b/Source/WebCore/css/query/MediaQueryFeatures.cpp
@@ -75,6 +75,23 @@ struct IntegerSchema : public FeatureSchema {
     ValueFunction valueFunction;
 };
 
+struct NumberSchema : public FeatureSchema {
+    using ValueFunction = Function<double(const FeatureEvaluationContext&)>;
+
+    NumberSchema(const AtomString& name, ValueFunction&& valueFunction)
+        : FeatureSchema(name, FeatureSchema::Type::Range, { FeatureSchema::ValueType::Integer, FeatureSchema::ValueType::Number })
+        , valueFunction(WTFMove(valueFunction))
+    { }
+
+    EvaluationResult evaluate(const Feature& feature, const FeatureEvaluationContext& context) const override
+    {
+        return evaluateNumberFeature(feature, valueFunction(context));
+    }
+
+private:
+    ValueFunction valueFunction;
+};
+
 struct LengthSchema : public FeatureSchema {
     using ValueFunction = Function<LayoutUnit(const FeatureEvaluationContext&)>;
 
@@ -109,6 +126,23 @@ struct RatioSchema : public FeatureSchema {
     ValueFunction valueFunction;
 };
 
+struct ResolutionSchema : public FeatureSchema {
+    using ValueFunction = Function<double(const FeatureEvaluationContext&)>;
+
+    ResolutionSchema(const AtomString& name, ValueFunction&& valueFunction)
+        : FeatureSchema(name, FeatureSchema::Type::Range, { FeatureSchema::ValueType::Resolution })
+        , valueFunction(WTFMove(valueFunction))
+    { }
+
+    EvaluationResult evaluate(const Feature& feature, const FeatureEvaluationContext& context) const override
+    {
+        return evaluateResolutionFeature(feature, valueFunction(context));
+    }
+
+private:
+    ValueFunction valueFunction;
+};
+
 using MatchingIdentifiers = Vector<CSSValueID, 1>;
 
 struct IdentifierSchema : public FeatureSchema {
@@ -134,6 +168,23 @@ struct IdentifierSchema : public FeatureSchema {
     ValueFunction valueFunction;
 };
 
+static double deviceScaleFactor(const FeatureEvaluationContext& context)
+{
+    auto& frame = *context.document.frame();
+    auto mediaType = frame.view()->mediaType();
+
+    if (equalLettersIgnoringASCIICase(mediaType, "screen"_s))
+        return frame.page() ? frame.page()->deviceScaleFactor() : 1;
+
+    if (equalLettersIgnoringASCIICase(mediaType, "print"_s)) {
+        // The resolution of images while printing should not depend on the dpi
+        // of the screen. Until we support proper ways of querying this info
+        // we use 300px which is considered minimum for current printers.
+        return 3.125; // 300dpi / 96dpi;
+    }
+    return 0;
+}
+
 const FeatureSchema& animation()
 {
     static MainThreadNeverDestroyed<BooleanSchema> schema {
@@ -253,7 +304,16 @@ const FeatureSchema& deviceHeight()
     return schema;
 }
 
-const FeatureSchema& devicePixelRatio();
+const FeatureSchema& devicePixelRatio()
+{
+    static MainThreadNeverDestroyed<NumberSchema> schema {
+        "-webkit-device-pixel-ratio"_s,
+        [](auto& context) {
+            return deviceScaleFactor(context);
+        }
+    };
+    return schema;
+}
 
 const FeatureSchema& deviceWidth()
 {
@@ -495,7 +555,16 @@ const FeatureSchema& prefersReducedMotion()
     return schema;
 }
 
-const FeatureSchema& resolution();
+const FeatureSchema& resolution()
+{
+    static MainThreadNeverDestroyed<ResolutionSchema> schema {
+        "resolution"_s,
+        [](auto& context) {
+            return deviceScaleFactor(context);
+        }
+    };
+    return schema;
+}
 
 const FeatureSchema& scan()
 {
@@ -635,7 +704,7 @@ Vector<const FeatureSchema*> allSchemas()
         &colorIndex(),
         &deviceAspectRatio(),
         &deviceHeight(),
-// FIXME: &devicePixelRatio(),
+        &devicePixelRatio(),
         &deviceWidth(),
         &dynamicRange(),
         &forcedColors(),
@@ -649,7 +718,7 @@ Vector<const FeatureSchema*> allSchemas()
         &prefersContrast(),
         &prefersDarkInterface(),
         &prefersReducedMotion(),
-// FIXME: &resolution(),
+        &resolution(),
         &scan(),
         &transform2d(),
         &transform3d(),