| /* |
| * 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: |
| * 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 |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "third_party/blink/renderer/core/css/media_query_evaluator.h" |
| |
| #include "third_party/blink/public/common/css/forced_colors.h" |
| #include "third_party/blink/public/common/css/navigation_controls.h" |
| #include "third_party/blink/renderer/core/css/media_values.h" |
| |
| #include "third_party/blink/public/common/privacy_budget/identifiability_metric_builder.h" |
| #include "third_party/blink/public/common/privacy_budget/identifiability_study_settings.h" |
| #include "third_party/blink/public/common/privacy_budget/identifiable_surface.h" |
| #include "third_party/blink/public/common/privacy_budget/identifiable_token_builder.h" |
| #include "third_party/blink/public/mojom/manifest/display_mode.mojom-shared.h" |
| #include "third_party/blink/public/mojom/webpreferences/web_preferences.mojom-blink.h" |
| #include "third_party/blink/renderer/core/css/css_primitive_value.h" |
| #include "third_party/blink/renderer/core/css/css_resolution_units.h" |
| #include "third_party/blink/renderer/core/css/css_to_length_conversion_data.h" |
| #include "third_party/blink/renderer/core/css/media_feature_names.h" |
| #include "third_party/blink/renderer/core/css/media_features.h" |
| #include "third_party/blink/renderer/core/css/media_list.h" |
| #include "third_party/blink/renderer/core/css/media_query.h" |
| #include "third_party/blink/renderer/core/css/media_values_dynamic.h" |
| #include "third_party/blink/renderer/core/css/resolver/media_query_result.h" |
| #include "third_party/blink/renderer/core/css_value_keywords.h" |
| #include "third_party/blink/renderer/core/frame/local_frame.h" |
| #include "third_party/blink/renderer/core/frame/local_frame_view.h" |
| #include "third_party/blink/renderer/core/frame/settings.h" |
| #include "third_party/blink/renderer/core/frame/web_feature.h" |
| #include "third_party/blink/renderer/core/media_type_names.h" |
| #include "third_party/blink/renderer/core/probe/core_probes.h" |
| #include "third_party/blink/renderer/platform/geometry/float_rect.h" |
| #include "third_party/blink/renderer/platform/graphics/color_space_gamut.h" |
| #include "third_party/blink/renderer/platform/instrumentation/use_counter.h" |
| #include "third_party/blink/renderer/platform/privacy_budget/identifiability_digest_helpers.h" |
| #include "third_party/blink/renderer/platform/wtf/hash_map.h" |
| |
| namespace blink { |
| |
| using mojom::blink::HoverType; |
| using mojom::blink::PointerType; |
| |
| namespace { |
| |
| void RecordMediaQueryResult(Document* doc, |
| const MediaQueryExp& expr, |
| bool result) { |
| IdentifiableTokenBuilder input_builder; |
| input_builder.AddToken(IdentifiabilityBenignStringToken(expr.MediaFeature())); |
| input_builder.AddToken( |
| IdentifiabilityBenignStringToken(expr.ExpValue().CssText())); |
| IdentifiableSurface surface = IdentifiableSurface::FromTypeAndToken( |
| IdentifiableSurface::Type::kMediaQuery, input_builder.GetToken()); |
| |
| IdentifiabilityMetricBuilder(doc->UkmSourceID()) |
| .Set(surface, result) |
| .Record(doc->UkmRecorder()); |
| } |
| |
| } // namespace |
| |
| enum MediaFeaturePrefix { kMinPrefix, kMaxPrefix, kNoPrefix }; |
| |
| using EvalFunc = bool (*)(const MediaQueryExpValue&, |
| MediaFeaturePrefix, |
| const MediaValues&); |
| using FunctionMap = HashMap<StringImpl*, EvalFunc>; |
| static FunctionMap* g_function_map; |
| |
| MediaQueryEvaluator::MediaQueryEvaluator(const char* accepted_media_type) |
| : media_type_(accepted_media_type) {} |
| |
| MediaQueryEvaluator::MediaQueryEvaluator(LocalFrame* frame) |
| : media_values_(MediaValues::CreateDynamicIfFrameExists(frame)) {} |
| |
| MediaQueryEvaluator::MediaQueryEvaluator(const MediaValues& media_values) |
| : media_values_(media_values.Copy()) {} |
| |
| MediaQueryEvaluator::~MediaQueryEvaluator() = default; |
| |
| void MediaQueryEvaluator::Trace(Visitor* visitor) const { |
| visitor->Trace(media_values_); |
| } |
| |
| const String MediaQueryEvaluator::MediaType() const { |
| // If a static mediaType was given by the constructor, we use it here. |
| if (!media_type_.IsEmpty()) |
| return media_type_; |
| // Otherwise, we get one from mediaValues (which may be dynamic or cached). |
| if (media_values_) |
| return media_values_->MediaType(); |
| return g_null_atom; |
| } |
| |
| bool MediaQueryEvaluator::MediaTypeMatch( |
| const String& media_type_to_match) const { |
| return media_type_to_match.IsEmpty() || |
| EqualIgnoringASCIICase(media_type_to_match, media_type_names::kAll) || |
| EqualIgnoringASCIICase(media_type_to_match, MediaType()); |
| } |
| |
| static bool ApplyRestrictor(MediaQuery::RestrictorType r, bool value) { |
| return r == MediaQuery::kNot ? !value : value; |
| } |
| |
| bool MediaQueryEvaluator::Eval( |
| const MediaQuery& query, |
| MediaQueryResultList* viewport_dependent_media_query_results, |
| MediaQueryResultList* device_dependent_media_query_results) const { |
| if (!MediaTypeMatch(query.MediaType())) |
| return ApplyRestrictor(query.Restrictor(), false); |
| |
| const ExpressionHeapVector& expressions = query.Expressions(); |
| // Iterate through expressions, stop if any of them eval to false (AND |
| // semantics). |
| wtf_size_t i = 0; |
| for (; i < expressions.size(); ++i) { |
| bool expr_result = Eval(expressions.at(i)); |
| if (viewport_dependent_media_query_results && |
| expressions.at(i).IsViewportDependent()) { |
| viewport_dependent_media_query_results->push_back( |
| MediaQueryResult(expressions.at(i), expr_result)); |
| } |
| if (device_dependent_media_query_results && |
| expressions.at(i).IsDeviceDependent()) { |
| device_dependent_media_query_results->push_back( |
| MediaQueryResult(expressions.at(i), expr_result)); |
| } |
| if (!expr_result) |
| break; |
| } |
| |
| // Assume true if we are at the end of the list, otherwise assume false. |
| return ApplyRestrictor(query.Restrictor(), expressions.size() == i); |
| } |
| |
| bool MediaQueryEvaluator::Eval( |
| const MediaQuerySet& query_set, |
| MediaQueryResultList* viewport_dependent_media_query_results, |
| MediaQueryResultList* device_dependent_media_query_results) const { |
| const Vector<std::unique_ptr<MediaQuery>>& queries = query_set.QueryVector(); |
| if (!queries.size()) |
| return true; // Empty query list evaluates to true. |
| |
| // Iterate over queries, stop if any of them eval to true (OR semantics). |
| bool result = false; |
| for (wtf_size_t i = 0; i < queries.size() && !result; ++i) |
| result = Eval(*queries[i], viewport_dependent_media_query_results, |
| device_dependent_media_query_results); |
| |
| return result; |
| } |
| |
| bool MediaQueryEvaluator::DidResultsChange( |
| const MediaQueryResultList& results) const { |
| base::AutoReset<bool> skip(&skip_ukm_reporting_, true); |
| for (auto& result : results) { |
| if (Eval(result.Expression()) != result.Result()) |
| return true; |
| } |
| return false; |
| } |
| |
| bool MediaQueryEvaluator::DidResultsChange( |
| const Vector<MediaQuerySetResult>& results) const { |
| base::AutoReset<bool> skip(&skip_ukm_reporting_, true); |
| for (const auto& result : results) { |
| if (result.Result() != Eval(result.MediaQueries())) |
| return true; |
| } |
| return false; |
| } |
| |
| template <typename T> |
| bool CompareValue(T a, T b, MediaFeaturePrefix op) { |
| switch (op) { |
| case kMinPrefix: |
| return a >= b; |
| case kMaxPrefix: |
| return a <= b; |
| case kNoPrefix: |
| return a == b; |
| } |
| return false; |
| } |
| |
| bool CompareDoubleValue(double a, double b, MediaFeaturePrefix op) { |
| const double precision = LayoutUnit::Epsilon(); |
| switch (op) { |
| case kMinPrefix: |
| return a >= (b - precision); |
| case kMaxPrefix: |
| return a <= (b + precision); |
| case kNoPrefix: |
| return std::abs(a - b) <= precision; |
| } |
| return false; |
| } |
| |
| static bool CompareAspectRatioValue(const MediaQueryExpValue& value, |
| int width, |
| int height, |
| MediaFeaturePrefix op) { |
| if (value.is_ratio) { |
| return CompareValue(static_cast<double>(width) * value.denominator, |
| static_cast<double>(height) * value.numerator, op); |
| } |
| return false; |
| } |
| |
| static bool NumberValue(const MediaQueryExpValue& value, float& result) { |
| if (value.is_value && value.unit == CSSPrimitiveValue::UnitType::kNumber) { |
| result = value.value; |
| return true; |
| } |
| return false; |
| } |
| |
| static bool ColorMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| float number; |
| int bits_per_component = media_values.ColorBitsPerComponent(); |
| if (value.IsValid()) |
| return NumberValue(value, number) && |
| CompareValue(bits_per_component, static_cast<int>(number), op); |
| |
| return bits_per_component != 0; |
| } |
| |
| static bool ColorIndexMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues&) { |
| // FIXME: We currently assume that we do not support indexed displays, as it |
| // is unknown how to retrieve the information if the display mode is indexed. |
| // This matches Firefox. |
| if (!value.IsValid()) |
| return false; |
| |
| // Acording to spec, if the device does not use a color lookup table, the |
| // value is zero. |
| float number; |
| return NumberValue(value, number) && |
| CompareValue(0, static_cast<int>(number), op); |
| } |
| |
| static bool MonochromeMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| float number; |
| int bits_per_component = media_values.MonochromeBitsPerComponent(); |
| if (value.IsValid()) { |
| return NumberValue(value, number) && |
| CompareValue(bits_per_component, static_cast<int>(number), op); |
| } |
| return bits_per_component != 0; |
| } |
| |
| static bool DisplayModeMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| // isValid() is false if there is no parameter. Without parameter we should |
| // return true to indicate that displayModeMediaFeature is enabled in the |
| // browser. |
| if (!value.IsValid()) |
| return true; |
| |
| if (!value.is_id) |
| return false; |
| |
| blink::mojom::DisplayMode mode = media_values.DisplayMode(); |
| switch (value.id) { |
| case CSSValueID::kFullscreen: |
| return mode == blink::mojom::DisplayMode::kFullscreen; |
| case CSSValueID::kStandalone: |
| return mode == blink::mojom::DisplayMode::kStandalone; |
| case CSSValueID::kMinimalUi: |
| return mode == blink::mojom::DisplayMode::kMinimalUi; |
| case CSSValueID::kBrowser: |
| return mode == blink::mojom::DisplayMode::kBrowser; |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| static bool OrientationMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| int width = media_values.ViewportWidth(); |
| int height = media_values.ViewportHeight(); |
| |
| if (value.is_id) { |
| if (width > height) // Square viewport is portrait. |
| return CSSValueID::kLandscape == value.id; |
| return CSSValueID::kPortrait == value.id; |
| } |
| |
| // Expression (orientation) evaluates to true if width and height >= 0. |
| return height >= 0 && width >= 0; |
| } |
| |
| static bool AspectRatioMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| if (value.IsValid()) |
| return CompareAspectRatioValue(value, media_values.ViewportWidth(), |
| media_values.ViewportHeight(), op); |
| |
| // ({,min-,max-}aspect-ratio) |
| // assume if we have a device, its aspect ratio is non-zero. |
| return true; |
| } |
| |
| static bool DeviceAspectRatioMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| if (value.IsValid()) |
| return CompareAspectRatioValue(value, media_values.DeviceWidth(), |
| media_values.DeviceHeight(), op); |
| |
| // ({,min-,max-}device-aspect-ratio) |
| // assume if we have a device, its aspect ratio is non-zero. |
| return true; |
| } |
| |
| static bool EvalResolution(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| // According to MQ4, only 'screen', 'print' and 'speech' may match. |
| // FIXME: What should speech match? |
| // https://www.w3.org/Style/CSS/Tracker/issues/348 |
| float actual_resolution = 0; |
| |
| // This checks the actual media type applied to the document, and we know |
| // this method only got called if this media type matches the one defined |
| // in the query. Thus, if if the document's media type is "print", the |
| // media type of the query will either be "print" or "all". |
| if (EqualIgnoringASCIICase(media_values.MediaType(), |
| media_type_names::kScreen)) { |
| actual_resolution = clampTo<float>(media_values.DevicePixelRatio()); |
| } else if (EqualIgnoringASCIICase(media_values.MediaType(), |
| media_type_names::kPrint)) { |
| // 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. |
| actual_resolution = 300 / kCssPixelsPerInch; |
| } |
| |
| if (!value.IsValid()) |
| return !!actual_resolution; |
| |
| if (!value.is_value) |
| return false; |
| |
| if (value.unit == CSSPrimitiveValue::UnitType::kNumber) |
| return CompareValue(actual_resolution, clampTo<float>(value.value), op); |
| |
| if (!CSSPrimitiveValue::IsResolution(value.unit)) |
| return false; |
| |
| double canonical_factor = |
| CSSPrimitiveValue::ConversionToCanonicalUnitsScaleFactor(value.unit); |
| double dppx_factor = CSSPrimitiveValue::ConversionToCanonicalUnitsScaleFactor( |
| CSSPrimitiveValue::UnitType::kDotsPerPixel); |
| float value_in_dppx = |
| clampTo<float>(value.value * (canonical_factor / dppx_factor)); |
| if (value.unit == CSSPrimitiveValue::UnitType::kDotsPerCentimeter) { |
| // To match DPCM to DPPX values, we limit to 2 decimal points. |
| // The https://drafts.csswg.org/css-values/#absolute-lengths recommends |
| // "that the pixel unit refer to the whole number of device pixels that best |
| // approximates the reference pixel". With that in mind, allowing 2 decimal |
| // point precision seems appropriate. |
| return CompareValue(floorf(0.5 + 100 * actual_resolution) / 100, |
| floorf(0.5 + 100 * value_in_dppx) / 100, op); |
| } |
| |
| return CompareValue(actual_resolution, value_in_dppx, op); |
| } |
| |
| static bool DevicePixelRatioMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| UseCounter::Count(media_values.GetDocument(), |
| WebFeature::kPrefixedDevicePixelRatioMediaFeature); |
| |
| return (!value.IsValid() || |
| value.unit == CSSPrimitiveValue::UnitType::kNumber) && |
| EvalResolution(value, op, media_values); |
| } |
| |
| static bool ResolutionMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| return (!value.IsValid() || CSSPrimitiveValue::IsResolution(value.unit)) && |
| EvalResolution(value, op, media_values); |
| } |
| |
| static bool GridMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues&) { |
| // if output device is bitmap, grid: 0 == true |
| // assume we have bitmap device |
| float number; |
| if (value.IsValid() && NumberValue(value, number)) |
| return CompareValue(static_cast<int>(number), 0, op); |
| return false; |
| } |
| |
| static bool ComputeLength(const MediaQueryExpValue& value, |
| const MediaValues& media_values, |
| double& result) { |
| if (!value.is_value) |
| return false; |
| |
| if (value.unit == CSSPrimitiveValue::UnitType::kNumber) { |
| result = clampTo<int>(value.value); |
| return !media_values.StrictMode() || !result; |
| } |
| |
| if (CSSPrimitiveValue::IsLength(value.unit)) |
| return media_values.ComputeLength(value.value, value.unit, result); |
| return false; |
| } |
| |
| static bool ComputeLengthAndCompare(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values, |
| double compare_to_value) { |
| double length; |
| return ComputeLength(value, media_values, length) && |
| CompareDoubleValue(compare_to_value, length, op); |
| } |
| |
| static bool DeviceHeightMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| if (value.IsValid()) |
| return ComputeLengthAndCompare(value, op, media_values, |
| media_values.DeviceHeight()); |
| |
| // ({,min-,max-}device-height) |
| // assume if we have a device, assume non-zero |
| return true; |
| } |
| |
| static bool DeviceWidthMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| if (value.IsValid()) |
| return ComputeLengthAndCompare(value, op, media_values, |
| media_values.DeviceWidth()); |
| |
| // ({,min-,max-}device-width) |
| // assume if we have a device, assume non-zero |
| return true; |
| } |
| |
| static bool HeightMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| double height = media_values.ViewportHeight(); |
| if (value.IsValid()) |
| return ComputeLengthAndCompare(value, op, media_values, height); |
| |
| return height; |
| } |
| |
| static bool WidthMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| double width = media_values.ViewportWidth(); |
| if (value.IsValid()) |
| return ComputeLengthAndCompare(value, op, media_values, width); |
| |
| return width; |
| } |
| |
| // Rest of the functions are trampolines which set the prefix according to the |
| // media feature expression used. |
| |
| static bool MinColorMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return ColorMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxColorMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return ColorMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinColorIndexMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return ColorIndexMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxColorIndexMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return ColorIndexMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinMonochromeMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return MonochromeMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxMonochromeMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return MonochromeMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinAspectRatioMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return AspectRatioMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxAspectRatioMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return AspectRatioMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinDeviceAspectRatioMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return DeviceAspectRatioMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxDeviceAspectRatioMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return DeviceAspectRatioMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinDevicePixelRatioMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| UseCounter::Count(media_values.GetDocument(), |
| WebFeature::kPrefixedMinDevicePixelRatioMediaFeature); |
| |
| return DevicePixelRatioMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxDevicePixelRatioMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| UseCounter::Count(media_values.GetDocument(), |
| WebFeature::kPrefixedMaxDevicePixelRatioMediaFeature); |
| |
| return DevicePixelRatioMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinHeightMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return HeightMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxHeightMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return HeightMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinWidthMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return WidthMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxWidthMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return WidthMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinDeviceHeightMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return DeviceHeightMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxDeviceHeightMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return DeviceHeightMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinDeviceWidthMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return DeviceWidthMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxDeviceWidthMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return DeviceWidthMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool MinResolutionMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return ResolutionMediaFeatureEval(value, kMinPrefix, media_values); |
| } |
| |
| static bool MaxResolutionMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| return ResolutionMediaFeatureEval(value, kMaxPrefix, media_values); |
| } |
| |
| static bool Transform3dMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| UseCounter::Count(media_values.GetDocument(), |
| WebFeature::kPrefixedTransform3dMediaFeature); |
| |
| bool return_value_if_no_parameter; |
| int have3d_rendering; |
| |
| bool three_d_enabled = media_values.ThreeDEnabled(); |
| |
| return_value_if_no_parameter = three_d_enabled; |
| have3d_rendering = three_d_enabled ? 1 : 0; |
| |
| if (value.IsValid()) { |
| float number; |
| return NumberValue(value, number) && |
| CompareValue(have3d_rendering, static_cast<int>(number), op); |
| } |
| return return_value_if_no_parameter; |
| } |
| |
| static bool ImmersiveMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix op, |
| const MediaValues& media_values) { |
| bool return_value_if_no_parameter; |
| int is_immersive_numeric_value; |
| |
| bool immersive = media_values.InImmersiveMode(); |
| |
| return_value_if_no_parameter = immersive; |
| is_immersive_numeric_value = immersive ? 1 : 0; |
| |
| if (value.IsValid()) { |
| float number; |
| return NumberValue(value, number) && |
| CompareValue(is_immersive_numeric_value, static_cast<int>(number), |
| op); |
| } |
| return return_value_if_no_parameter; |
| } |
| |
| static bool HoverMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| HoverType hover = media_values.PrimaryHoverType(); |
| |
| if (!value.IsValid()) |
| return hover != HoverType::kHoverNone; |
| |
| if (!value.is_id) |
| return false; |
| |
| return (hover == HoverType::kHoverNone && value.id == CSSValueID::kNone) || |
| (hover == HoverType::kHoverHoverType && |
| value.id == CSSValueID::kHover); |
| } |
| |
| static bool AnyHoverMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| int available_hover_types = media_values.AvailableHoverTypes(); |
| |
| if (!value.IsValid()) |
| return available_hover_types & ~static_cast<int>(HoverType::kHoverNone); |
| |
| if (!value.is_id) |
| return false; |
| |
| switch (value.id) { |
| case CSSValueID::kNone: |
| return available_hover_types & static_cast<int>(HoverType::kHoverNone); |
| case CSSValueID::kHover: |
| return available_hover_types & |
| static_cast<int>(HoverType::kHoverHoverType); |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| static bool OriginTrialTestMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| // The test feature only supports a 'no-value' parsing. So if we've gotten |
| // to this point it will always match. |
| DCHECK(!value.IsValid()); |
| return true; |
| } |
| |
| static bool PointerMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| PointerType pointer = media_values.PrimaryPointerType(); |
| |
| if (!value.IsValid()) |
| return pointer != PointerType::kPointerNone; |
| |
| if (!value.is_id) |
| return false; |
| |
| return (pointer == PointerType::kPointerNone && |
| value.id == CSSValueID::kNone) || |
| (pointer == PointerType::kPointerCoarseType && |
| value.id == CSSValueID::kCoarse) || |
| (pointer == PointerType::kPointerFineType && |
| value.id == CSSValueID::kFine); |
| } |
| |
| static bool PrefersReducedMotionMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| // If the value is not valid, this was passed without an argument. In that |
| // case, it implicitly resolves to 'reduce'. |
| if (!value.IsValid()) |
| return media_values.PrefersReducedMotion(); |
| |
| if (!value.is_id) |
| return false; |
| |
| return (value.id == CSSValueID::kNoPreference) ^ |
| media_values.PrefersReducedMotion(); |
| } |
| |
| static bool PrefersReducedDataMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| if (!value.IsValid()) |
| return media_values.PrefersReducedData(); |
| |
| if (!value.is_id) |
| return false; |
| |
| return (value.id == CSSValueID::kNoPreference) ^ |
| media_values.PrefersReducedData(); |
| } |
| |
| static bool AnyPointerMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| int available_pointers = media_values.AvailablePointerTypes(); |
| |
| if (!value.IsValid()) { |
| return available_pointers & ~static_cast<int>(PointerType::kPointerNone); |
| } |
| |
| if (!value.is_id) |
| return false; |
| |
| switch (value.id) { |
| case CSSValueID::kCoarse: |
| return available_pointers & |
| static_cast<int>(PointerType::kPointerCoarseType); |
| case CSSValueID::kFine: |
| return available_pointers & |
| static_cast<int>(PointerType::kPointerFineType); |
| case CSSValueID::kNone: |
| return available_pointers & static_cast<int>(PointerType::kPointerNone); |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| static bool ScanMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| // Scan only applies to 'tv' media. |
| if (!EqualIgnoringASCIICase(media_values.MediaType(), media_type_names::kTv)) |
| return false; |
| |
| if (!value.IsValid()) |
| return true; |
| |
| if (!value.is_id) |
| 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 == CSSValueID::kProgressive); |
| } |
| |
| static bool ColorGamutMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| // 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.is_id) |
| return false; |
| |
| DCHECK(value.id == CSSValueID::kSRGB || value.id == CSSValueID::kP3 || |
| value.id == CSSValueID::kRec2020); |
| |
| ColorSpaceGamut gamut = media_values.ColorGamut(); |
| switch (gamut) { |
| case ColorSpaceGamut::kUnknown: |
| case ColorSpaceGamut::kLessThanNTSC: |
| case ColorSpaceGamut::NTSC: |
| case ColorSpaceGamut::SRGB: |
| return value.id == CSSValueID::kSRGB; |
| case ColorSpaceGamut::kAlmostP3: |
| case ColorSpaceGamut::P3: |
| case ColorSpaceGamut::kAdobeRGB: |
| case ColorSpaceGamut::kWide: |
| return value.id == CSSValueID::kSRGB || value.id == CSSValueID::kP3; |
| case ColorSpaceGamut::BT2020: |
| case ColorSpaceGamut::kProPhoto: |
| case ColorSpaceGamut::kUltraWide: |
| return value.id == CSSValueID::kSRGB || value.id == CSSValueID::kP3 || |
| value.id == CSSValueID::kRec2020; |
| case ColorSpaceGamut::kEnd: |
| NOTREACHED(); |
| return false; |
| } |
| |
| // This is for some compilers that do not understand that it can't be reached. |
| NOTREACHED(); |
| return false; |
| } |
| |
| static bool PrefersColorSchemeMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| auto preferred_scheme = media_values.GetPreferredColorScheme(); |
| |
| if (!value.IsValid()) |
| return true; |
| |
| if (!value.is_id) |
| return false; |
| |
| return (preferred_scheme == mojom::blink::PreferredColorScheme::kDark && |
| value.id == CSSValueID::kDark) || |
| (preferred_scheme == mojom::blink::PreferredColorScheme::kLight && |
| value.id == CSSValueID::kLight); |
| } |
| |
| static bool PrefersContrastMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| auto preferred_contrast = media_values.GetPreferredContrast(); |
| ForcedColors forced_colors = media_values.GetForcedColors(); |
| |
| if (!value.IsValid()) { |
| return forced_colors != ForcedColors::kNone || |
| preferred_contrast != mojom::blink::PreferredContrast::kNoPreference; |
| } |
| |
| if (!value.is_id) |
| return false; |
| |
| switch (value.id) { |
| case CSSValueID::kForced: |
| return forced_colors == ForcedColors::kActive; |
| case CSSValueID::kMore: |
| return preferred_contrast == mojom::blink::PreferredContrast::kMore; |
| case CSSValueID::kLess: |
| return preferred_contrast == mojom::blink::PreferredContrast::kLess; |
| case CSSValueID::kNoPreference: |
| return forced_colors != ForcedColors::kActive && |
| preferred_contrast == |
| mojom::blink::PreferredContrast::kNoPreference; |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| static bool ForcedColorsMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| ForcedColors forced_colors = media_values.GetForcedColors(); |
| |
| if (!value.IsValid()) |
| return forced_colors != ForcedColors::kNone; |
| |
| if (!value.is_id) |
| return false; |
| |
| // Check the forced colors against value.id. |
| return (forced_colors == ForcedColors::kNone && |
| value.id == CSSValueID::kNone) || |
| (forced_colors != ForcedColors::kNone && |
| value.id == CSSValueID::kActive); |
| } |
| |
| static bool NavigationControlsMediaFeatureEval( |
| const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| NavigationControls navigation_controls = media_values.GetNavigationControls(); |
| |
| if (!value.IsValid()) |
| return navigation_controls != NavigationControls::kNone; |
| |
| if (!value.is_id) |
| return false; |
| |
| // Check the navigation controls against value.id. |
| return (navigation_controls == NavigationControls::kNone && |
| value.id == CSSValueID::kNone) || |
| (navigation_controls == NavigationControls::kBackButton && |
| value.id == CSSValueID::kBackButton); |
| } |
| |
| static bool ScreenSpanningMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| ScreenSpanning screen_spanning_mode = media_values.GetScreenSpanning(); |
| |
| if (!value.IsValid()) |
| return screen_spanning_mode != ScreenSpanning::kNone; |
| |
| // We should not have parsed a valid MediaQueryExpValue if the value is not |
| // an identifier. |
| DCHECK(value.is_id); |
| |
| return (screen_spanning_mode == ScreenSpanning::kNone && |
| value.id == CSSValueID::kNone) || |
| (screen_spanning_mode == ScreenSpanning::kSingleFoldVertical && |
| value.id == CSSValueID::kSingleFoldVertical) || |
| (screen_spanning_mode == ScreenSpanning::kSingleFoldHorizontal && |
| value.id == CSSValueID::kSingleFoldHorizontal); |
| } |
| |
| static bool ScreenFoldPostureMediaFeatureEval(const MediaQueryExpValue& value, |
| MediaFeaturePrefix, |
| const MediaValues& media_values) { |
| // isValid() is false if there is no parameter. Without parameter we should |
| // return true to indicate that screenFoldPosture is enabled in the |
| // browser. |
| if (!value.IsValid()) |
| return true; |
| |
| DCHECK(value.is_id); |
| |
| ScreenFoldPosture screen_fold_posture = media_values.GetScreenFoldPosture(); |
| switch (value.id) { |
| case CSSValueID::kNoFold: |
| return screen_fold_posture == ScreenFoldPosture::kNoFold; |
| case CSSValueID::kLaptop: |
| return screen_fold_posture == ScreenFoldPosture::kLaptop; |
| case CSSValueID::kFlat: |
| return screen_fold_posture == ScreenFoldPosture::kFlat; |
| case CSSValueID::kTent: |
| return screen_fold_posture == ScreenFoldPosture::kTent; |
| case CSSValueID::kTablet: |
| return screen_fold_posture == ScreenFoldPosture::kTablet; |
| case CSSValueID::kBook: |
| return screen_fold_posture == ScreenFoldPosture::kBook; |
| default: |
| NOTREACHED(); |
| return false; |
| } |
| } |
| |
| void MediaQueryEvaluator::Init() { |
| // Create the table. |
| g_function_map = new FunctionMap; |
| #define ADD_TO_FUNCTIONMAP(constantPrefix, methodPrefix) \ |
| g_function_map->Set(constantPrefix##MediaFeature.Impl(), \ |
| methodPrefix##MediaFeatureEval); |
| CSS_MEDIAQUERY_NAMES_FOR_EACH_MEDIAFEATURE(ADD_TO_FUNCTIONMAP); |
| #undef ADD_TO_FUNCTIONMAP |
| } |
| |
| bool MediaQueryEvaluator::Eval(const MediaQueryExp& expr) const { |
| if (!media_values_ || !media_values_->HasValues()) { |
| // media_values_ should only be nullptr when parsing UA stylesheets. The |
| // only media queries we support in UA stylesheets are media type queries. |
| // If HasValues() return false, it means the document frame is nullptr. |
| NOTREACHED(); |
| return false; |
| } |
| |
| DCHECK(g_function_map); |
| |
| // Call the media feature evaluation function. Assume no prefix and let |
| // trampoline functions override the prefix if prefix is used. |
| EvalFunc func = g_function_map->at(expr.MediaFeature().Impl()); |
| if (func) { |
| bool result = func(expr.ExpValue(), kNoPrefix, *media_values_); |
| Document* doc = nullptr; |
| if (!skip_ukm_reporting_ && (doc = media_values_->GetDocument()) && |
| (IdentifiabilityStudySettings::Get()->ShouldSample( |
| IdentifiableSurface::Type::kMediaQuery))) { |
| RecordMediaQueryResult(doc, expr, result); |
| } |
| |
| return result; |
| } |
| |
| return false; |
| } |
| |
| } // namespace blink |
