From 8d8b5942be72367242cb5aa9f33844d1eda66597 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Emilio=20Cobos=20=C3=81lvarez?= Date: Fri, 11 Aug 2023 02:05:08 +0200 Subject: [PATCH] style: Make media feature evaluation take a computed::Context This has no behavior change right now, but will simplify sharing code with container queries. Container queries will have container information in the computed::Context (this is necessary anyways for container-based units), so this avoids having to have different code for media and container queries. Differential Revision: https://phabricator.services.mozilla.com/D144152 --- components/style/gecko/media_features.rs | 168 +++++++++--------- .../style/media_queries/media_condition.rs | 16 +- .../style/media_queries/media_feature.rs | 12 +- .../media_queries/media_feature_expression.rs | 26 ++- components/style/media_queries/media_list.rs | 12 +- .../values/specified/source_size_list.rs | 10 +- 6 files changed, 119 insertions(+), 125 deletions(-) diff --git a/components/style/gecko/media_features.rs b/components/style/gecko/media_features.rs index 57c41c95e95..9789d9646b6 100644 --- a/components/style/gecko/media_features.rs +++ b/components/style/gecko/media_features.rs @@ -9,9 +9,7 @@ use crate::gecko_bindings::structs; use crate::media_queries::media_feature::{AllowsRanges, ParsingRequirements}; use crate::media_queries::media_feature::{Evaluator, MediaFeatureDescription}; use crate::media_queries::{Device, MediaType}; -use crate::values::computed::CSSPixelLength; -use crate::values::computed::Ratio; -use crate::values::computed::Resolution; +use crate::values::computed::{Context, CSSPixelLength, Ratio, Resolution}; use app_units::Au; use euclid::default::Size2D; @@ -25,46 +23,46 @@ fn device_size(device: &Device) -> Size2D { } /// https://drafts.csswg.org/mediaqueries-4/#width -fn eval_width(device: &Device) -> CSSPixelLength { - CSSPixelLength::new(device.au_viewport_size().width.to_f32_px()) +fn eval_width(context: &Context) -> CSSPixelLength { + CSSPixelLength::new(context.device().au_viewport_size().width.to_f32_px()) } /// https://drafts.csswg.org/mediaqueries-4/#device-width -fn eval_device_width(device: &Device) -> CSSPixelLength { - CSSPixelLength::new(device_size(device).width.to_f32_px()) +fn eval_device_width(context: &Context) -> CSSPixelLength { + CSSPixelLength::new(device_size(context.device()).width.to_f32_px()) } /// https://drafts.csswg.org/mediaqueries-4/#height -fn eval_height(device: &Device) -> CSSPixelLength { - CSSPixelLength::new(device.au_viewport_size().height.to_f32_px()) +fn eval_height(context: &Context) -> CSSPixelLength { + CSSPixelLength::new(context.device().au_viewport_size().height.to_f32_px()) } /// https://drafts.csswg.org/mediaqueries-4/#device-height -fn eval_device_height(device: &Device) -> CSSPixelLength { - CSSPixelLength::new(device_size(device).height.to_f32_px()) +fn eval_device_height(context: &Context) -> CSSPixelLength { + CSSPixelLength::new(device_size(context.device()).height.to_f32_px()) } -fn eval_aspect_ratio_for(device: &Device, get_size: F) -> Ratio +fn eval_aspect_ratio_for(context: &Context, get_size: F) -> Ratio where F: FnOnce(&Device) -> Size2D, { - let size = get_size(device); + let size = get_size(context.device()); Ratio::new(size.width.0 as f32, size.height.0 as f32) } /// https://drafts.csswg.org/mediaqueries-4/#aspect-ratio -fn eval_aspect_ratio(device: &Device) -> Ratio { - eval_aspect_ratio_for(device, Device::au_viewport_size) +fn eval_aspect_ratio(context: &Context) -> Ratio { + eval_aspect_ratio_for(context, Device::au_viewport_size) } /// https://drafts.csswg.org/mediaqueries-4/#device-aspect-ratio -fn eval_device_aspect_ratio(device: &Device) -> Ratio { - eval_aspect_ratio_for(device, device_size) +fn eval_device_aspect_ratio(context: &Context) -> Ratio { + eval_aspect_ratio_for(context, device_size) } /// https://compat.spec.whatwg.org/#css-media-queries-webkit-device-pixel-ratio -fn eval_device_pixel_ratio(device: &Device) -> f32 { - eval_resolution(device).dppx() +fn eval_device_pixel_ratio(context: &Context) -> f32 { + eval_resolution(context).dppx() } #[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)] @@ -74,7 +72,7 @@ enum Orientation { Portrait, } -fn eval_orientation_for(device: &Device, value: Option, get_size: F) -> bool +fn eval_orientation_for(context: &Context, value: Option, get_size: F) -> bool where F: FnOnce(&Device) -> Size2D, { @@ -83,7 +81,7 @@ where None => return true, }; - let size = get_size(device); + let size = get_size(context.device()); // Per spec, square viewports should be 'portrait' let is_landscape = size.width > size.height; @@ -94,13 +92,13 @@ where } /// https://drafts.csswg.org/mediaqueries-4/#orientation -fn eval_orientation(device: &Device, value: Option) -> bool { - eval_orientation_for(device, value, Device::au_viewport_size) +fn eval_orientation(context: &Context, value: Option) -> bool { + eval_orientation_for(context, value, Device::au_viewport_size) } /// FIXME: There's no spec for `-moz-device-orientation`. -fn eval_device_orientation(device: &Device, value: Option) -> bool { - eval_orientation_for(device, value, device_size) +fn eval_device_orientation(context: &Context, value: Option) -> bool { + eval_orientation_for(context, value, device_size) } /// Values for the display-mode media feature. @@ -115,22 +113,22 @@ pub enum DisplayMode { } /// https://w3c.github.io/manifest/#the-display-mode-media-feature -fn eval_display_mode(device: &Device, query_value: Option) -> bool { +fn eval_display_mode(context: &Context, query_value: Option) -> bool { match query_value { - Some(v) => v == unsafe { bindings::Gecko_MediaFeatures_GetDisplayMode(device.document()) }, + Some(v) => v == unsafe { bindings::Gecko_MediaFeatures_GetDisplayMode(context.device().document()) }, None => true, } } /// https://drafts.csswg.org/mediaqueries-4/#grid -fn eval_grid(_: &Device) -> bool { +fn eval_grid(_: &Context) -> bool { // Gecko doesn't support grid devices (e.g., ttys), so the 'grid' feature // is always 0. false } /// https://compat.spec.whatwg.org/#css-media-queries-webkit-transform-3d -fn eval_transform_3d(_: &Device) -> bool { +fn eval_transform_3d(_: &Context) -> bool { true } @@ -142,32 +140,32 @@ enum Scan { } /// https://drafts.csswg.org/mediaqueries-4/#scan -fn eval_scan(_: &Device, _: Option) -> bool { +fn eval_scan(_: &Context, _: Option) -> bool { // Since Gecko doesn't support the 'tv' media type, the 'scan' feature never // matches. false } /// https://drafts.csswg.org/mediaqueries-4/#color -fn eval_color(device: &Device) -> u32 { - unsafe { bindings::Gecko_MediaFeatures_GetColorDepth(device.document()) } +fn eval_color(context: &Context) -> u32 { + unsafe { bindings::Gecko_MediaFeatures_GetColorDepth(context.device().document()) } } /// https://drafts.csswg.org/mediaqueries-4/#color-index -fn eval_color_index(_: &Device) -> u32 { +fn eval_color_index(_: &Context) -> u32 { // We should return zero if the device does not use a color lookup table. 0 } /// https://drafts.csswg.org/mediaqueries-4/#monochrome -fn eval_monochrome(device: &Device) -> u32 { +fn eval_monochrome(context: &Context) -> u32 { // For color devices we should return 0. - unsafe { bindings::Gecko_MediaFeatures_GetMonochromeBitsPerPixel(device.document()) } + unsafe { bindings::Gecko_MediaFeatures_GetMonochromeBitsPerPixel(context.device().document()) } } /// https://drafts.csswg.org/mediaqueries-4/#resolution -fn eval_resolution(device: &Device) -> Resolution { - let resolution_dppx = unsafe { bindings::Gecko_MediaFeatures_GetResolution(device.document()) }; +fn eval_resolution(context: &Context) -> Resolution { + let resolution_dppx = unsafe { bindings::Gecko_MediaFeatures_GetResolution(context.device().document()) }; Resolution::from_dppx(resolution_dppx) } @@ -200,9 +198,9 @@ pub enum DynamicRange { } /// https://drafts.csswg.org/mediaqueries-5/#prefers-reduced-motion -fn eval_prefers_reduced_motion(device: &Device, query_value: Option) -> bool { +fn eval_prefers_reduced_motion(context: &Context, query_value: Option) -> bool { let prefers_reduced = - unsafe { bindings::Gecko_MediaFeatures_PrefersReducedMotion(device.document()) }; + unsafe { bindings::Gecko_MediaFeatures_PrefersReducedMotion(context.device().document()) }; let query_value = match query_value { Some(v) => v, None => return prefers_reduced, @@ -230,9 +228,9 @@ pub enum PrefersContrast { } /// https://drafts.csswg.org/mediaqueries-5/#prefers-contrast -fn eval_prefers_contrast(device: &Device, query_value: Option) -> bool { +fn eval_prefers_contrast(context: &Context, query_value: Option) -> bool { let prefers_contrast = - unsafe { bindings::Gecko_MediaFeatures_PrefersContrast(device.document()) }; + unsafe { bindings::Gecko_MediaFeatures_PrefersContrast(context.device().document()) }; match query_value { Some(v) => v == prefers_contrast, None => prefers_contrast != PrefersContrast::NoPreference, @@ -251,8 +249,8 @@ pub enum ForcedColors { } /// https://drafts.csswg.org/mediaqueries-5/#forced-colors -fn eval_forced_colors(device: &Device, query_value: Option) -> bool { - let forced = !device.use_document_colors(); +fn eval_forced_colors(context: &Context, query_value: Option) -> bool { + let forced = !context.device().use_document_colors(); match query_value { Some(query_value) => forced == (query_value == ForcedColors::Active), None => forced, @@ -269,7 +267,7 @@ enum OverflowBlock { } /// https://drafts.csswg.org/mediaqueries-4/#mf-overflow-block -fn eval_overflow_block(device: &Device, query_value: Option) -> bool { +fn eval_overflow_block(context: &Context, query_value: Option) -> bool { // For the time being, assume that printing (including previews) // is the only time when we paginate, and we are otherwise always // scrolling. This is true at the moment in Firefox, but may need @@ -277,7 +275,7 @@ fn eval_overflow_block(device: &Device, query_value: Option) -> b // billboard mode that doesn't support overflow at all). // // If this ever changes, don't forget to change eval_overflow_inline too. - let scrolling = device.media_type() != MediaType::print(); + let scrolling = context.device().media_type() != MediaType::print(); let query_value = match query_value { Some(v) => v, None => return true, @@ -298,9 +296,9 @@ enum OverflowInline { } /// https://drafts.csswg.org/mediaqueries-4/#mf-overflow-inline -fn eval_overflow_inline(device: &Device, query_value: Option) -> bool { +fn eval_overflow_inline(context: &Context, query_value: Option) -> bool { // See the note in eval_overflow_block. - let scrolling = device.media_type() != MediaType::print(); + let scrolling = context.device().media_type() != MediaType::print(); let query_value = match query_value { Some(v) => v, None => return scrolling, @@ -313,12 +311,12 @@ fn eval_overflow_inline(device: &Device, query_value: Option) -> } fn do_eval_prefers_color_scheme( - device: &Device, + context: &Context, use_content: bool, query_value: Option, ) -> bool { let prefers_color_scheme = - unsafe { bindings::Gecko_MediaFeatures_PrefersColorScheme(device.document(), use_content) }; + unsafe { bindings::Gecko_MediaFeatures_PrefersColorScheme(context.device().document(), use_content) }; match query_value { Some(v) => prefers_color_scheme == v, None => true, @@ -326,30 +324,30 @@ fn do_eval_prefers_color_scheme( } /// https://drafts.csswg.org/mediaqueries-5/#prefers-color-scheme -fn eval_prefers_color_scheme(device: &Device, query_value: Option) -> bool { - do_eval_prefers_color_scheme(device, /* use_content = */ false, query_value) +fn eval_prefers_color_scheme(context: &Context, query_value: Option) -> bool { + do_eval_prefers_color_scheme(context, /* use_content = */ false, query_value) } fn eval_content_prefers_color_scheme( - device: &Device, + context: &Context, query_value: Option, ) -> bool { - do_eval_prefers_color_scheme(device, /* use_content = */ true, query_value) + do_eval_prefers_color_scheme(context, /* use_content = */ true, query_value) } /// https://drafts.csswg.org/mediaqueries-5/#dynamic-range -fn eval_dynamic_range(device: &Device, query_value: Option) -> bool { +fn eval_dynamic_range(context: &Context, query_value: Option) -> bool { let dynamic_range = - unsafe { bindings::Gecko_MediaFeatures_DynamicRange(device.document()) }; + unsafe { bindings::Gecko_MediaFeatures_DynamicRange(context.device().document()) }; match query_value { Some(v) => dynamic_range >= v, None => false, } } /// https://drafts.csswg.org/mediaqueries-5/#video-dynamic-range -fn eval_video_dynamic_range(device: &Device, query_value: Option) -> bool { +fn eval_video_dynamic_range(context: &Context, query_value: Option) -> bool { let dynamic_range = - unsafe { bindings::Gecko_MediaFeatures_VideoDynamicRange(device.document()) }; + unsafe { bindings::Gecko_MediaFeatures_VideoDynamicRange(context.device().document()) }; match query_value { Some(v) => dynamic_range >= v, None => false, @@ -365,15 +363,15 @@ bitflags! { } } -fn primary_pointer_capabilities(device: &Device) -> PointerCapabilities { +fn primary_pointer_capabilities(context: &Context) -> PointerCapabilities { PointerCapabilities::from_bits_truncate(unsafe { - bindings::Gecko_MediaFeatures_PrimaryPointerCapabilities(device.document()) + bindings::Gecko_MediaFeatures_PrimaryPointerCapabilities(context.device().document()) }) } -fn all_pointer_capabilities(device: &Device) -> PointerCapabilities { +fn all_pointer_capabilities(context: &Context) -> PointerCapabilities { PointerCapabilities::from_bits_truncate(unsafe { - bindings::Gecko_MediaFeatures_AllPointerCapabilities(device.document()) + bindings::Gecko_MediaFeatures_AllPointerCapabilities(context.device().document()) }) } @@ -402,13 +400,13 @@ fn eval_pointer_capabilities( } /// https://drafts.csswg.org/mediaqueries-4/#pointer -fn eval_pointer(device: &Device, query_value: Option) -> bool { - eval_pointer_capabilities(query_value, primary_pointer_capabilities(device)) +fn eval_pointer(context: &Context, query_value: Option) -> bool { + eval_pointer_capabilities(query_value, primary_pointer_capabilities(context)) } /// https://drafts.csswg.org/mediaqueries-4/#descdef-media-any-pointer -fn eval_any_pointer(device: &Device, query_value: Option) -> bool { - eval_pointer_capabilities(query_value, all_pointer_capabilities(device)) +fn eval_any_pointer(context: &Context, query_value: Option) -> bool { + eval_pointer_capabilities(query_value, all_pointer_capabilities(context)) } #[derive(Clone, Copy, Debug, FromPrimitive, Parse, ToCss)] @@ -435,33 +433,33 @@ fn eval_hover_capabilities( } /// https://drafts.csswg.org/mediaqueries-4/#hover -fn eval_hover(device: &Device, query_value: Option) -> bool { - eval_hover_capabilities(query_value, primary_pointer_capabilities(device)) +fn eval_hover(context: &Context, query_value: Option) -> bool { + eval_hover_capabilities(query_value, primary_pointer_capabilities(context)) } /// https://drafts.csswg.org/mediaqueries-4/#descdef-media-any-hover -fn eval_any_hover(device: &Device, query_value: Option) -> bool { - eval_hover_capabilities(query_value, all_pointer_capabilities(device)) +fn eval_any_hover(context: &Context, query_value: Option) -> bool { + eval_hover_capabilities(query_value, all_pointer_capabilities(context)) } -fn eval_moz_is_glyph(device: &Device) -> bool { - device.document().mIsSVGGlyphsDocument() +fn eval_moz_is_glyph(context: &Context) -> bool { + context.device().document().mIsSVGGlyphsDocument() } -fn eval_moz_print_preview(device: &Device) -> bool { - let is_print_preview = device.is_print_preview(); +fn eval_moz_print_preview(context: &Context) -> bool { + let is_print_preview = context.device().is_print_preview(); if is_print_preview { - debug_assert_eq!(device.media_type(), MediaType::print()); + debug_assert_eq!(context.device().media_type(), MediaType::print()); } is_print_preview } -fn eval_moz_non_native_content_theme(device: &Device) -> bool { - unsafe { bindings::Gecko_MediaFeatures_ShouldAvoidNativeTheme(device.document()) } +fn eval_moz_non_native_content_theme(context: &Context) -> bool { + unsafe { bindings::Gecko_MediaFeatures_ShouldAvoidNativeTheme(context.device().document()) } } -fn eval_moz_is_resource_document(device: &Device) -> bool { - unsafe { bindings::Gecko_MediaFeatures_IsResourceDocument(device.document()) } +fn eval_moz_is_resource_document(context: &Context) -> bool { + unsafe { bindings::Gecko_MediaFeatures_IsResourceDocument(context.device().document()) } } /// Allows front-end CSS to discern platform via media queries. @@ -487,7 +485,7 @@ pub enum Platform { WindowsWin10, } -fn eval_moz_platform(_: &Device, query_value: Option) -> bool { +fn eval_moz_platform(_: &Context, query_value: Option) -> bool { let query_value = match query_value { Some(v) => v, None => return false, @@ -496,13 +494,13 @@ fn eval_moz_platform(_: &Device, query_value: Option) -> bool { unsafe { bindings::Gecko_MediaFeatures_MatchesPlatform(query_value) } } -fn eval_moz_windows_non_native_menus(device: &Device) -> bool { +fn eval_moz_windows_non_native_menus(context: &Context) -> bool { let use_non_native_menus = match static_prefs::pref!("browser.display.windows.non_native_menus") { 0 => false, 1 => true, _ => { - eval_moz_platform(device, Some(Platform::WindowsWin10)) && + eval_moz_platform(context, Some(Platform::WindowsWin10)) && get_lnf_int_as_bool(bindings::LookAndFeel_IntID::WindowsDefaultTheme as i32) }, }; @@ -510,8 +508,8 @@ fn eval_moz_windows_non_native_menus(device: &Device) -> bool { use_non_native_menus } -fn eval_moz_overlay_scrollbars(device: &Device) -> bool { - unsafe { bindings::Gecko_MediaFeatures_UseOverlayScrollbars(device.document()) } +fn eval_moz_overlay_scrollbars(context: &Context) -> bool { + unsafe { bindings::Gecko_MediaFeatures_UseOverlayScrollbars(context.device().document()) } } fn get_lnf_int(int_id: i32) -> i32 { @@ -540,7 +538,7 @@ fn get_scrollbar_end_forward(int_id: i32) -> bool { macro_rules! lnf_int_feature { ($feature_name:expr, $int_id:ident, $get_value:ident) => {{ - fn __eval(_: &Device) -> bool { + fn __eval(_: &Context) -> bool { $get_value(bindings::LookAndFeel_IntID::$int_id as i32) } @@ -567,7 +565,7 @@ macro_rules! lnf_int_feature { /// you also need to add them to kMediaQueryPrefs in nsXPLookAndFeel.cpp macro_rules! bool_pref_feature { ($feature_name:expr, $pref:tt) => {{ - fn __eval(_: &Device) -> bool { + fn __eval(_: &Context) -> bool { static_prefs::pref!($pref) } diff --git a/components/style/media_queries/media_condition.rs b/components/style/media_queries/media_condition.rs index f735704556e..63e130ba4ff 100644 --- a/components/style/media_queries/media_condition.rs +++ b/components/style/media_queries/media_condition.rs @@ -6,9 +6,9 @@ //! //! https://drafts.csswg.org/mediaqueries-4/#typedef-media-condition -use super::{Device, MediaFeatureExpression}; -use crate::context::QuirksMode; +use super::MediaFeatureExpression; use crate::parser::ParserContext; +use crate::values::computed; use cssparser::{Parser, Token}; use std::fmt::{self, Write}; use style_traits::{CssWriter, ParseError, StyleParseErrorKind, ToCss}; @@ -168,16 +168,16 @@ impl MediaCondition { } /// Whether this condition matches the device and quirks mode. - pub fn matches(&self, device: &Device, quirks_mode: QuirksMode) -> bool { + pub fn matches(&self, context: &computed::Context) -> bool { match *self { - MediaCondition::Feature(ref f) => f.matches(device, quirks_mode), - MediaCondition::InParens(ref c) => c.matches(device, quirks_mode), - MediaCondition::Not(ref c) => !c.matches(device, quirks_mode), + MediaCondition::Feature(ref f) => f.matches(context), + MediaCondition::InParens(ref c) => c.matches(context), + MediaCondition::Not(ref c) => !c.matches(context), MediaCondition::Operation(ref conditions, op) => { let mut iter = conditions.iter(); match op { - Operator::And => iter.all(|c| c.matches(device, quirks_mode)), - Operator::Or => iter.any(|c| c.matches(device, quirks_mode)), + Operator::And => iter.all(|c| c.matches(context)), + Operator::Or => iter.any(|c| c.matches(context)), } }, } diff --git a/components/style/media_queries/media_feature.rs b/components/style/media_queries/media_feature.rs index 7eb51b9f513..df39d0245a0 100644 --- a/components/style/media_queries/media_feature.rs +++ b/components/style/media_queries/media_feature.rs @@ -4,10 +4,8 @@ //! Media features. -use super::Device; use crate::parser::ParserContext; -use crate::values::computed::Ratio; -use crate::values::computed::{CSSPixelLength, Resolution}; +use crate::values::computed::{self, CSSPixelLength, Resolution, Ratio}; use crate::Atom; use cssparser::Parser; use std::fmt; @@ -16,7 +14,7 @@ use style_traits::ParseError; /// A generic discriminant for an enum value. pub type KeywordDiscriminant = u8; -type MediaFeatureGetter = fn(device: &Device) -> T; +type MediaFeatureGetter = fn(device: &computed::Context) -> T; /// Serializes a given discriminant. /// @@ -54,7 +52,7 @@ pub enum Evaluator { serializer: KeywordSerializer, /// The evaluator itself. This is guaranteed to be called with a /// keyword that `parser` has produced. - evaluator: fn(&Device, Option) -> bool, + evaluator: fn(&computed::Context, Option) -> bool, }, } @@ -84,14 +82,14 @@ macro_rules! keyword_evaluator { } fn __evaluate( - device: &$crate::media_queries::Device, + context: &$crate::values::computed::Context, value: Option<$crate::media_queries::media_feature::KeywordDiscriminant>, ) -> bool { // This unwrap is ok because the only discriminants that get // back to us is the ones that `parse` produces. let value: Option<$keyword_type> = value.map(|kw| ::num_traits::cast::FromPrimitive::from_u8(kw).unwrap()); - $actual_evaluator(device, value) + $actual_evaluator(context, value) } $crate::media_queries::media_feature::Evaluator::Enumerated { diff --git a/components/style/media_queries/media_feature_expression.rs b/components/style/media_queries/media_feature_expression.rs index 772560143ee..651dbf0002f 100644 --- a/components/style/media_queries/media_feature_expression.rs +++ b/components/style/media_queries/media_feature_expression.rs @@ -7,8 +7,6 @@ use super::media_feature::{Evaluator, MediaFeatureDescription}; use super::media_feature::{KeywordDiscriminant, ParsingRequirements}; -use super::Device; -use crate::context::QuirksMode; #[cfg(feature = "gecko")] use crate::gecko::media_features::MEDIA_FEATURES; use crate::parser::{Parse, ParserContext}; @@ -381,7 +379,7 @@ impl MediaFeatureExpression { } /// Returns whether this media query evaluates to true for the given device. - pub fn matches(&self, device: &Device, quirks_mode: QuirksMode) -> bool { + pub fn matches(&self, context: &computed::Context) -> bool { let value = self.value.as_ref(); macro_rules! expect { @@ -396,21 +394,19 @@ impl MediaFeatureExpression { match self.feature().evaluator { Evaluator::Length(eval) => { let computed = expect!(Length).map(|specified| { - computed::Context::for_media_query_evaluation(device, quirks_mode, |context| { - specified.to_computed_value(context) - }) + specified.to_computed_value(context) }); - let length = eval(device); + let length = eval(context); RangeOrOperator::evaluate(self.range_or_operator, computed, length) }, Evaluator::Integer(eval) => { let computed = expect!(Integer).cloned(); - let integer = eval(device); + let integer = eval(context); RangeOrOperator::evaluate(self.range_or_operator, computed, integer) }, Evaluator::Float(eval) => { let computed = expect!(Float).cloned(); - let float = eval(device); + let float = eval(context); RangeOrOperator::evaluate(self.range_or_operator, computed, float) } Evaluator::NumberRatio(eval) => { @@ -422,26 +418,24 @@ impl MediaFeatureExpression { Some(ratio) => ratio.used_value(), None => return true, }; - let ratio = eval(device); + let ratio = eval(context); RangeOrOperator::evaluate_with_query_value(self.range_or_operator, computed, ratio) }, Evaluator::Resolution(eval) => { let computed = expect!(Resolution).map(|specified| { - computed::Context::for_media_query_evaluation(device, quirks_mode, |context| { - specified.to_computed_value(context).dppx() - }) + specified.to_computed_value(context).dppx() }); - let resolution = eval(device).dppx(); + let resolution = eval(context).dppx(); RangeOrOperator::evaluate(self.range_or_operator, computed, resolution) }, Evaluator::Enumerated { evaluator, .. } => { debug_assert!(self.range_or_operator.is_none(), "Ranges with keywords?"); - evaluator(device, expect!(Enumerated).cloned()) + evaluator(context, expect!(Enumerated).cloned()) }, Evaluator::BoolInteger(eval) => { debug_assert!(self.range_or_operator.is_none(), "Ranges with bools?"); let computed = expect!(BoolInteger).cloned(); - let boolean = eval(device); + let boolean = eval(context); computed.map_or(boolean, |v| v == boolean) }, } diff --git a/components/style/media_queries/media_list.rs b/components/style/media_queries/media_list.rs index abc2ae6dbc8..8ce317db534 100644 --- a/components/style/media_queries/media_list.rs +++ b/components/style/media_queries/media_list.rs @@ -10,6 +10,7 @@ use super::{Device, MediaQuery, Qualifier}; use crate::context::QuirksMode; use crate::error_reporting::ContextualParseError; use crate::parser::ParserContext; +use crate::values::computed; use cssparser::{Delimiter, Parser}; use cssparser::{ParserInput, Token}; @@ -74,15 +75,17 @@ impl MediaList { pub fn evaluate(&self, device: &Device, quirks_mode: QuirksMode) -> bool { // Check if it is an empty media query list or any queries match. // https://drafts.csswg.org/mediaqueries-4/#mq-list - self.media_queries.is_empty() || + if self.media_queries.is_empty() { + return true; + } + + computed::Context::for_media_query_evaluation(device, quirks_mode, |context| { self.media_queries.iter().any(|mq| { let media_match = mq.media_type.matches(device.media_type()); // Check if the media condition match. let query_match = media_match && - mq.condition - .as_ref() - .map_or(true, |c| c.matches(device, quirks_mode)); + mq.condition.as_ref().map_or(true, |c| c.matches(context)); // Apply the logical NOT qualifier to the result match mq.qualifier { @@ -90,6 +93,7 @@ impl MediaList { _ => query_match, } }) + }) } /// Whether this `MediaList` contains no media queries. diff --git a/components/style/values/specified/source_size_list.rs b/components/style/values/specified/source_size_list.rs index edb2c09f73e..fe1731d981f 100644 --- a/components/style/values/specified/source_size_list.rs +++ b/components/style/values/specified/source_size_list.rs @@ -56,12 +56,12 @@ impl SourceSizeList { /// Evaluate this to get the final viewport length. pub fn evaluate(&self, device: &Device, quirks_mode: QuirksMode) -> Au { - let matching_source_size = self - .source_sizes - .iter() - .find(|source_size| source_size.condition.matches(device, quirks_mode)); - computed::Context::for_media_query_evaluation(device, quirks_mode, |context| { + let matching_source_size = self + .source_sizes + .iter() + .find(|source_size| source_size.condition.matches(context)); + match matching_source_size { Some(source_size) => source_size.value.to_computed_value(context), None => match self.value {