Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-04 13:10:20 +01:00
Code Issues Projects Releases Packages Wiki Activity

style: Rustfmt cascade.rs.

Browse source 
Differential Revision: https://phabricator.services.mozilla.com/D105186
This commit is contained in:
Emilio Cobos Álvarez 2021-02-16 13:38:08 +00:00
parent 48db30f6e2
commit 36e6c68c9f
1 changed files with 76 additions and 76 deletions
Download patch file Download diff file Expand all files Collapse all files

152
components/style/properties/cascade.rs
View file

@ -10,21 +10,23 @@ use crate::dom::TElement;
use crate::font_metrics::FontMetricsProvider;
use crate::logical_geometry::WritingMode;
use crate::media_queries::Device;
use crate::properties::{ComputedValues, StyleBuilder, Importance};
use crate::properties::{LonghandId, LonghandIdSet, CSSWideKeyword, PropertyFlags};
use crate::properties::{PropertyDeclaration, PropertyDeclarationId, DeclarationImportanceIterator};
use crate::properties::{CASCADE_PROPERTY, ComputedValueFlags};
use crate::properties::{CSSWideKeyword, LonghandId, LonghandIdSet, PropertyFlags};
use crate::properties::{ComputedValueFlags, CASCADE_PROPERTY};
use crate::properties::{ComputedValues, Importance, StyleBuilder};
use crate::properties::{
DeclarationImportanceIterator, PropertyDeclaration, PropertyDeclarationId,
};
use crate::rule_cache::{RuleCache, RuleCacheConditions};
use crate::rule_tree::StrongRuleNode;
use crate::selector_parser::PseudoElement;
use crate::stylesheets::{Origin, PerOrigin};
use servo_arc::Arc;
use crate::shared_lock::StylesheetGuards;
use crate::style_adjuster::StyleAdjuster;
use crate::stylesheets::{Origin, PerOrigin};
use crate::values::{computed, specified};
use servo_arc::Arc;
use smallvec::SmallVec;
use std::borrow::Cow;
use std::cell::RefCell;
use crate::style_adjuster::StyleAdjuster;
use crate::values::{computed, specified};
/// We split the cascade in two phases: 'early' properties, and 'late'
/// properties.
@ -121,7 +123,11 @@ struct DeclarationIterator<'a> {
impl<'a> DeclarationIterator<'a> {
#[inline]
fn new(rule_node: &'a StrongRuleNode, guards: &'a StylesheetGuards, pseudo: Option<&PseudoElement>) -> Self {
fn new(
rule_node: &'a StrongRuleNode,
guards: &'a StylesheetGuards,
pseudo: Option<&PseudoElement>,
) -> Self {
let restriction = pseudo.and_then(|p| p.property_restriction());
let mut iter = Self {
guards,
@ -148,7 +154,6 @@ impl<'a> DeclarationIterator<'a> {
None => DeclarationImportanceIterator::default(),
};
}
}
impl<'a> Iterator for DeclarationIterator<'a> {
@ -282,10 +287,7 @@ where
let mut declarations = SmallVec::<[(&_, Origin); 32]>::new();
let custom_properties = {
let mut builder = CustomPropertiesBuilder::new(
inherited_style.custom_properties(),
device,
);
let mut builder = CustomPropertiesBuilder::new(inherited_style.custom_properties(), device);
for (declaration, origin) in iter {
declarations.push((declaration, origin));
@ -297,9 +299,7 @@ where
builder.build()
};
let is_root_element =
pseudo.is_none() && element.map_or(false, |e| e.is_root());
let is_root_element = pseudo.is_none() && element.map_or(false, |e| e.is_root());
let mut context = computed::Context {
// We'd really like to own the rules here to avoid refcount traffic, but
@ -326,8 +326,10 @@ where
let using_cached_reset_properties = {
let mut cascade = Cascade::new(&mut context, cascade_mode);
cascade
.apply_properties::<EarlyProperties, _>(ApplyResetProperties::Yes, declarations.iter().cloned());
cascade.apply_properties::<EarlyProperties, _>(
ApplyResetProperties::Yes,
declarations.iter().cloned(),
);
cascade.compute_visited_style_if_needed(
element,
@ -376,7 +378,7 @@ where
/// given initial value if nothing in other origins did override it.
///
/// This is a bit of a clunky way of achieving this.
type DeclarationsToApplyUnlessOverriden = SmallVec::<[PropertyDeclaration; 2]>;
type DeclarationsToApplyUnlessOverriden = SmallVec<[PropertyDeclaration; 2]>;
fn tweak_when_ignoring_colors(
builder: &StyleBuilder,
@ -399,7 +401,9 @@ fn tweak_when_ignoring_colors(
// Don't override background-color on ::-moz-color-swatch. It is set as an
// author style (via the style attribute), but it's pretty important for it
// to show up for obvious reasons :)
if builder.pseudo.map_or(false, |p| p.is_color_swatch()) && longhand_id == LonghandId::BackgroundColor {
if builder.pseudo.map_or(false, |p| p.is_color_swatch()) &&
longhand_id == LonghandId::BackgroundColor
{
return;
}
@ -442,11 +446,10 @@ fn tweak_when_ignoring_colors(
if alpha != 0 {
let mut color = builder.device.default_background_color();
color.alpha = alpha;
declarations_to_apply_unless_overriden.push(
PropertyDeclaration::BackgroundColor(color.into())
)
declarations_to_apply_unless_overriden
.push(PropertyDeclaration::BackgroundColor(color.into()))
}
}
},
PropertyDeclaration::Color(ref color) => {
// We honor color: transparent, and "revert-or-initial" otherwise.
if alpha_channel(&color.0) == 0 {
@ -457,9 +460,9 @@ fn tweak_when_ignoring_colors(
// the default color. Otherwise just let it inherit through.
if builder.get_parent_inherited_text().clone_color().alpha == 0 {
let color = builder.device.default_color();
declarations_to_apply_unless_overriden.push(
PropertyDeclaration::Color(specified::ColorPropertyValue(color.into()))
)
declarations_to_apply_unless_overriden.push(PropertyDeclaration::Color(
specified::ColorPropertyValue(color.into()),
))
}
},
// We honor url background-images if backplating.
@ -475,8 +478,8 @@ fn tweak_when_ignoring_colors(
_ => {},
}
*declaration.to_mut() = PropertyDeclaration::css_wide_keyword(longhand_id, CSSWideKeyword::Revert);
*declaration.to_mut() =
PropertyDeclaration::css_wide_keyword(longhand_id, CSSWideKeyword::Revert);
}
struct Cascade<'a, 'b: 'a> {
@ -542,11 +545,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
}
#[inline(always)]
fn apply_declaration(
&mut self,
longhand_id: LonghandId,
declaration: &PropertyDeclaration,
) {
fn apply_declaration(&mut self, longhand_id: LonghandId, declaration: &PropertyDeclaration) {
// We could (and used to) use a pattern match here, but that bloats this
// function to over 100K of compiled code!
//
@ -574,8 +573,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
);
let ignore_colors = !self.context.builder.device.use_document_colors();
let mut declarations_to_apply_unless_overriden =
DeclarationsToApplyUnlessOverriden::new();
let mut declarations_to_apply_unless_overriden = DeclarationsToApplyUnlessOverriden::new();
for (declaration, origin) in declarations {
let declaration_id = declaration.id();
@ -604,7 +602,11 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
continue;
}
if self.reverted.borrow_for_origin(&origin).contains(physical_longhand_id) {
if self
.reverted
.borrow_for_origin(&origin)
.contains(physical_longhand_id)
{
continue;
}
@ -654,13 +656,11 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
self.author_specified.insert(physical_longhand_id);
}
let unset = css_wide_keyword.map_or(false, |css_wide_keyword| {
match css_wide_keyword {
CSSWideKeyword::Unset => true,
CSSWideKeyword::Inherit => inherited,
CSSWideKeyword::Initial => !inherited,
CSSWideKeyword::Revert => unreachable!(),
}
let unset = css_wide_keyword.map_or(false, |css_wide_keyword| match css_wide_keyword {
CSSWideKeyword::Unset => true,
CSSWideKeyword::Inherit => inherited,
CSSWideKeyword::Initial => !inherited,
CSSWideKeyword::Revert => unreachable!(),
});
if unset {
@ -756,7 +756,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
// styles, we cache the unvisited style instead. We still do
// need to set the caching dependencies properly if present
// though, so the cache conditions need to match.
/* rule_cache = */ None,
None, // rule_cache
&mut *self.context.rule_cache_conditions.borrow_mut(),
element,
);
@ -775,13 +775,18 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
if let Some(svg) = builder.get_svg_if_mutated() {
svg.fill_arrays();
}
}
if self.author_specified.contains_any(LonghandIdSet::border_background_properties()) {
if self
.author_specified
.contains_any(LonghandIdSet::border_background_properties())
{
builder.add_flags(ComputedValueFlags::HAS_AUTHOR_SPECIFIED_BORDER_BACKGROUND);
}
if self.author_specified.contains_any(LonghandIdSet::padding_properties()) {
if self
.author_specified
.contains_any(LonghandIdSet::padding_properties())
{
builder.add_flags(ComputedValueFlags::HAS_AUTHOR_SPECIFIED_PADDING);
}
@ -818,8 +823,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
//
// Note that all the properties involved are non-inherited, so we don't
// need to do anything else other than just copying the bits over.
let reset_props_bits =
ComputedValueFlags::HAS_AUTHOR_SPECIFIED_BORDER_BACKGROUND |
let reset_props_bits = ComputedValueFlags::HAS_AUTHOR_SPECIFIED_BORDER_BACKGROUND |
ComputedValueFlags::HAS_AUTHOR_SPECIFIED_PADDING;
builder.add_flags(cached_style.flags & reset_props_bits);
@ -838,8 +842,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
use crate::gecko_bindings::bindings;
use crate::values::computed::font::GenericFontFamily;
if !self.seen.contains(LonghandId::XLang) &&
!self.seen.contains(LonghandId::FontFamily) {
if !self.seen.contains(LonghandId::XLang) && !self.seen.contains(LonghandId::FontFamily) {
return;
}
@ -851,7 +854,10 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
// System fonts are all right, and should have the default font type
// set to none already, so bail out early.
if font.mFont.systemFont {
debug_assert_eq!(font.mFont.fontlist.mDefaultFontType, GenericFontFamily::None);
debug_assert_eq!(
font.mFont.fontlist.mDefaultFontType,
GenericFontFamily::None
);
return;
}
@ -867,13 +873,12 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
// and we don't have a generic family already (or we're using
// cursive or fantasy, since they're ignored, see bug 789788), and
// we have a generic family to actually replace it with.
let prioritize_user_fonts =
!use_document_fonts &&
let prioritize_user_fonts = !use_document_fonts &&
matches!(
font.mGenericID,
GenericFontFamily::None |
GenericFontFamily::Fantasy |
GenericFontFamily::Cursive
GenericFontFamily::Fantasy |
GenericFontFamily::Cursive
) &&
default_font_type != GenericFontFamily::None;
@ -887,9 +892,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
let font = builder.mutate_font().gecko_mut();
font.mFont.fontlist.mDefaultFontType = default_font_type;
if prioritize_user_fonts {
unsafe {
bindings::Gecko_nsStyleFont_PrioritizeUserFonts(font, default_font_type)
}
unsafe { bindings::Gecko_nsStyleFont_PrioritizeUserFonts(font, default_font_type) }
}
}
@ -899,8 +902,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
use crate::values::computed::ToComputedValue;
use crate::values::specified;
if !self.seen.contains(LonghandId::XLang) &&
!self.seen.contains(LonghandId::FontFamily) {
if !self.seen.contains(LonghandId::XLang) && !self.seen.contains(LonghandId::FontFamily) {
return;
}
@ -912,7 +914,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
_ => {
self.context.for_non_inherited_property = None;
specified::FontSize::Keyword(info).to_computed_value(self.context)
}
},
};
if font.gecko().mScriptUnconstrainedSize == new_size.size {
@ -933,9 +935,10 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
use crate::values::generics::NonNegative;
if !self.seen.contains(LonghandId::XLang) &&
!self.seen.contains(LonghandId::FontFamily) &&
!self.seen.contains(LonghandId::MozMinFontSizeRatio) &&
!self.seen.contains(LonghandId::FontSize) {
!self.seen.contains(LonghandId::FontFamily) &&
!self.seen.contains(LonghandId::MozMinFontSizeRatio) &&
!self.seen.contains(LonghandId::FontSize)
{
return;
}
@ -943,10 +946,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
let min_font_size = {
let font = builder.get_font().gecko();
let min_font_size = unsafe {
bindings::Gecko_nsStyleFont_ComputeMinSize(
font,
builder.device.document(),
)
bindings::Gecko_nsStyleFont_ComputeMinSize(font, builder.device.document())
};
if font.mFont.size.0 >= min_font_size {
@ -998,8 +998,9 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
use crate::values::generics::NonNegative;
if !self.seen.contains(LonghandId::MathDepth) &&
!self.seen.contains(LonghandId::MozScriptMinSize) &&
!self.seen.contains(LonghandId::MozScriptSizeMultiplier) {
!self.seen.contains(LonghandId::MozScriptMinSize) &&
!self.seen.contains(LonghandId::MozScriptSizeMultiplier)
{
return;
}
@ -1013,8 +1014,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
let font = builder.get_font().gecko();
let parent_font = builder.get_parent_font().gecko();
let delta =
font.mMathDepth.saturating_sub(parent_font.mMathDepth);
let delta = font.mMathDepth.saturating_sub(parent_font.mMathDepth);
if delta == 0 {
return;
@ -1049,7 +1049,7 @@ impl<'a, 'b: 'a> Cascade<'a, 'b> {
// of em units), use that instead.
(
new_size.min(new_unconstrained_size.max(min)),
new_unconstrained_size
new_unconstrained_size,
)
}
};