diff options
Diffstat (limited to 'servo/components/style/properties/declaration_block.rs')
| -rw-r--r-- | servo/components/style/properties/declaration_block.rs | 1613 |
1 files changed, 1613 insertions, 0 deletions
diff --git a/servo/components/style/properties/declaration_block.rs b/servo/components/style/properties/declaration_block.rs new file mode 100644 index 0000000000..90845af311 --- /dev/null +++ b/servo/components/style/properties/declaration_block.rs @@ -0,0 +1,1613 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +//! A property declaration block. + +#![deny(missing_docs)] + +use super::generated::{ + shorthands, AllShorthand, ComputedValues, LogicalGroupSet, LonghandIdSet, + NonCustomPropertyIdSet, PropertyDeclaration, PropertyDeclarationId, PropertyId, ShorthandId, + SourcePropertyDeclaration, SourcePropertyDeclarationDrain, SubpropertiesVec, +}; +use crate::applicable_declarations::CascadePriority; +use crate::context::QuirksMode; +use crate::custom_properties::{self, CustomPropertiesBuilder}; +use crate::error_reporting::{ContextualParseError, ParseErrorReporter}; +use crate::media_queries::Device; +use crate::parser::ParserContext; +use crate::properties::animated_properties::{AnimationValue, AnimationValueMap}; +use crate::rule_tree::CascadeLevel; +use crate::selector_map::PrecomputedHashSet; +use crate::selector_parser::SelectorImpl; +use crate::shared_lock::Locked; +use crate::str::{CssString, CssStringWriter}; +use crate::stylesheets::{layer_rule::LayerOrder, CssRuleType, Origin, UrlExtraData}; +use crate::values::computed::Context; +use cssparser::{ + parse_important, AtRuleParser, CowRcStr, DeclarationParser, Delimiter, ParseErrorKind, Parser, + ParserInput, QualifiedRuleParser, RuleBodyItemParser, RuleBodyParser, +}; +use itertools::Itertools; +use selectors::SelectorList; +use servo_arc::Arc; +use smallbitvec::{self, SmallBitVec}; +use smallvec::SmallVec; +use std::fmt::{self, Write}; +use std::iter::{DoubleEndedIterator, Zip}; +use std::slice::Iter; +use style_traits::{CssWriter, ParseError, ParsingMode, StyleParseErrorKind, ToCss}; +use thin_vec::ThinVec; + +/// A set of property declarations including animations and transitions. +#[derive(Default)] +pub struct AnimationDeclarations { + /// Declarations for animations. + pub animations: Option<Arc<Locked<PropertyDeclarationBlock>>>, + /// Declarations for transitions. + pub transitions: Option<Arc<Locked<PropertyDeclarationBlock>>>, +} + +impl AnimationDeclarations { + /// Whether or not this `AnimationDeclarations` is empty. + pub fn is_empty(&self) -> bool { + self.animations.is_none() && self.transitions.is_none() + } +} + +/// An enum describes how a declaration should update +/// the declaration block. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +enum DeclarationUpdate { + /// The given declaration doesn't update anything. + None, + /// The given declaration is new, and should be append directly. + Append, + /// The given declaration can be updated in-place at the given position. + UpdateInPlace { pos: usize }, + /// The given declaration cannot be updated in-place, and an existing + /// one needs to be removed at the given position. + AppendAndRemove { pos: usize }, +} + +/// A struct describes how a declaration block should be updated by +/// a `SourcePropertyDeclaration`. +#[derive(Default)] +pub struct SourcePropertyDeclarationUpdate { + updates: SubpropertiesVec<DeclarationUpdate>, + new_count: usize, + any_removal: bool, +} + +/// A declaration [importance][importance]. +/// +/// [importance]: https://drafts.csswg.org/css-cascade/#importance +#[derive(Clone, Copy, Debug, Eq, Hash, MallocSizeOf, PartialEq)] +pub enum Importance { + /// Indicates a declaration without `!important`. + Normal, + + /// Indicates a declaration with `!important`. + Important, +} + +impl Default for Importance { + fn default() -> Self { + Self::Normal + } +} + +impl Importance { + /// Return whether this is an important declaration. + pub fn important(self) -> bool { + match self { + Self::Normal => false, + Self::Important => true, + } + } +} + +#[derive(Clone, ToShmem, Default, MallocSizeOf)] +struct PropertyDeclarationIdSet { + longhands: LonghandIdSet, + custom: PrecomputedHashSet<custom_properties::Name>, +} + +impl PropertyDeclarationIdSet { + fn insert(&mut self, id: PropertyDeclarationId) -> bool { + match id { + PropertyDeclarationId::Longhand(id) => { + if self.longhands.contains(id) { + return false; + } + self.longhands.insert(id); + return true; + }, + PropertyDeclarationId::Custom(name) => self.custom.insert(name.clone()), + } + } + + fn contains(&self, id: PropertyDeclarationId) -> bool { + match id { + PropertyDeclarationId::Longhand(id) => self.longhands.contains(id), + PropertyDeclarationId::Custom(name) => self.custom.contains(name), + } + } + + fn remove(&mut self, id: PropertyDeclarationId) { + match id { + PropertyDeclarationId::Longhand(id) => self.longhands.remove(id), + PropertyDeclarationId::Custom(name) => { + self.custom.remove(name); + }, + } + } + + fn clear(&mut self) { + self.longhands.clear(); + self.custom.clear(); + } +} + +/// Overridden declarations are skipped. +#[cfg_attr(feature = "gecko", derive(MallocSizeOf))] +#[derive(Clone, ToShmem, Default)] +pub struct PropertyDeclarationBlock { + /// The group of declarations, along with their importance. + /// + /// Only deduplicated declarations appear here. + declarations: ThinVec<PropertyDeclaration>, + + /// The "important" flag for each declaration in `declarations`. + declarations_importance: SmallBitVec, + + /// The set of properties that are present in the block. + property_ids: PropertyDeclarationIdSet, +} + +/// Iterator over `(PropertyDeclaration, Importance)` pairs. +pub struct DeclarationImportanceIterator<'a> { + iter: Zip<Iter<'a, PropertyDeclaration>, smallbitvec::Iter<'a>>, +} + +impl<'a> Default for DeclarationImportanceIterator<'a> { + fn default() -> Self { + Self { + iter: [].iter().zip(smallbitvec::Iter::default()), + } + } +} + +impl<'a> DeclarationImportanceIterator<'a> { + /// Constructor. + fn new(declarations: &'a [PropertyDeclaration], important: &'a SmallBitVec) -> Self { + DeclarationImportanceIterator { + iter: declarations.iter().zip(important.iter()), + } + } +} + +impl<'a> Iterator for DeclarationImportanceIterator<'a> { + type Item = (&'a PropertyDeclaration, Importance); + + #[inline] + fn next(&mut self) -> Option<Self::Item> { + self.iter.next().map(|(decl, important)| { + ( + decl, + if important { + Importance::Important + } else { + Importance::Normal + }, + ) + }) + } + + #[inline] + fn size_hint(&self) -> (usize, Option<usize>) { + self.iter.size_hint() + } +} + +impl<'a> DoubleEndedIterator for DeclarationImportanceIterator<'a> { + #[inline(always)] + fn next_back(&mut self) -> Option<Self::Item> { + self.iter.next_back().map(|(decl, important)| { + ( + decl, + if important { + Importance::Important + } else { + Importance::Normal + }, + ) + }) + } +} + +/// Iterator for AnimationValue to be generated from PropertyDeclarationBlock. +pub struct AnimationValueIterator<'a, 'cx, 'cx_a: 'cx> { + iter: DeclarationImportanceIterator<'a>, + context: &'cx mut Context<'cx_a>, + default_values: &'a ComputedValues, + /// Custom properties in a keyframe if exists. + extra_custom_properties: Option<&'a Arc<crate::custom_properties::CustomPropertiesMap>>, +} + +impl<'a, 'cx, 'cx_a: 'cx> AnimationValueIterator<'a, 'cx, 'cx_a> { + fn new( + declarations: &'a PropertyDeclarationBlock, + context: &'cx mut Context<'cx_a>, + default_values: &'a ComputedValues, + extra_custom_properties: Option<&'a Arc<crate::custom_properties::CustomPropertiesMap>>, + ) -> AnimationValueIterator<'a, 'cx, 'cx_a> { + AnimationValueIterator { + iter: declarations.declaration_importance_iter(), + context, + default_values, + extra_custom_properties, + } + } +} + +impl<'a, 'cx, 'cx_a: 'cx> Iterator for AnimationValueIterator<'a, 'cx, 'cx_a> { + type Item = AnimationValue; + #[inline] + fn next(&mut self) -> Option<Self::Item> { + loop { + let (decl, importance) = self.iter.next()?; + + if importance.important() { + continue; + } + + let animation = AnimationValue::from_declaration( + decl, + &mut self.context, + self.extra_custom_properties, + self.default_values, + ); + + if let Some(anim) = animation { + return Some(anim); + } + } + } +} + +impl fmt::Debug for PropertyDeclarationBlock { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + self.declarations.fmt(f) + } +} + +impl PropertyDeclarationBlock { + /// Returns the number of declarations in the block. + #[inline] + pub fn len(&self) -> usize { + self.declarations.len() + } + + /// Returns whether the block is empty. + #[inline] + pub fn is_empty(&self) -> bool { + self.declarations.is_empty() + } + + /// Create an empty block + #[inline] + pub fn new() -> Self { + PropertyDeclarationBlock { + declarations: ThinVec::new(), + declarations_importance: SmallBitVec::new(), + property_ids: PropertyDeclarationIdSet::default(), + } + } + + /// Create a block with a single declaration + pub fn with_one(declaration: PropertyDeclaration, importance: Importance) -> Self { + let mut property_ids = PropertyDeclarationIdSet::default(); + property_ids.insert(declaration.id()); + let mut declarations = ThinVec::with_capacity(1); + declarations.push(declaration); + PropertyDeclarationBlock { + declarations, + declarations_importance: SmallBitVec::from_elem(1, importance.important()), + property_ids, + } + } + + /// The declarations in this block + #[inline] + pub fn declarations(&self) -> &[PropertyDeclaration] { + &self.declarations + } + + /// The `important` flags for declarations in this block + #[inline] + pub fn declarations_importance(&self) -> &SmallBitVec { + &self.declarations_importance + } + + /// Iterate over `(PropertyDeclaration, Importance)` pairs + #[inline] + pub fn declaration_importance_iter(&self) -> DeclarationImportanceIterator { + DeclarationImportanceIterator::new(&self.declarations, &self.declarations_importance) + } + + /// Iterate over `PropertyDeclaration` for Importance::Normal + #[inline] + pub fn normal_declaration_iter<'a>( + &'a self, + ) -> impl DoubleEndedIterator<Item = &'a PropertyDeclaration> { + self.declaration_importance_iter() + .filter(|(_, importance)| !importance.important()) + .map(|(declaration, _)| declaration) + } + + /// Return an iterator of (AnimatableLonghand, AnimationValue). + #[inline] + pub fn to_animation_value_iter<'a, 'cx, 'cx_a: 'cx>( + &'a self, + context: &'cx mut Context<'cx_a>, + default_values: &'a ComputedValues, + extra_custom_properties: Option<&'a Arc<crate::custom_properties::CustomPropertiesMap>>, + ) -> AnimationValueIterator<'a, 'cx, 'cx_a> { + AnimationValueIterator::new(self, context, default_values, extra_custom_properties) + } + + /// Returns whether this block contains any declaration with `!important`. + /// + /// This is based on the `declarations_importance` bit-vector, + /// which should be maintained whenever `declarations` is changed. + #[inline] + pub fn any_important(&self) -> bool { + !self.declarations_importance.all_false() + } + + /// Returns whether this block contains any declaration without `!important`. + /// + /// This is based on the `declarations_importance` bit-vector, + /// which should be maintained whenever `declarations` is changed. + #[inline] + pub fn any_normal(&self) -> bool { + !self.declarations_importance.all_true() + } + + /// Returns a `LonghandIdSet` representing the properties that are changed in + /// this block. + #[inline] + pub fn longhands(&self) -> &LonghandIdSet { + &self.property_ids.longhands + } + + /// Returns whether this block contains a declaration of a given property id. + #[inline] + pub fn contains(&self, id: PropertyDeclarationId) -> bool { + self.property_ids.contains(id) + } + + /// Returns whether this block contains any reset longhand. + #[inline] + pub fn contains_any_reset(&self) -> bool { + self.property_ids.longhands.contains_any_reset() + } + + /// Get a declaration for a given property. + /// + /// NOTE: This is linear time in the case of custom properties or in the + /// case the longhand is actually in the declaration block. + #[inline] + pub fn get( + &self, + property: PropertyDeclarationId, + ) -> Option<(&PropertyDeclaration, Importance)> { + if !self.contains(property) { + return None; + } + self.declaration_importance_iter() + .find(|(declaration, _)| declaration.id() == property) + } + + /// Tries to serialize a given shorthand from the declarations in this + /// block. + pub fn shorthand_to_css( + &self, + shorthand: ShorthandId, + dest: &mut CssStringWriter, + ) -> fmt::Result { + // Step 1.2.1 of + // https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertyvalue + let mut list = SmallVec::<[&_; 10]>::new(); + let mut important_count = 0; + + // Step 1.2.2 + for longhand in shorthand.longhands() { + // Step 1.2.2.1 + let declaration = self.get(PropertyDeclarationId::Longhand(longhand)); + + // Step 1.2.2.2 & 1.2.2.3 + match declaration { + Some((declaration, importance)) => { + list.push(declaration); + if importance.important() { + important_count += 1; + } + }, + None => return Ok(()), + } + } + + // If there is one or more longhand with important, and one or more + // without important, we don't serialize it as a shorthand. + if important_count > 0 && important_count != list.len() { + return Ok(()); + } + + // Step 1.2.3 + // We don't print !important when serializing individual properties, + // so we treat this as a normal-importance property + match shorthand.get_shorthand_appendable_value(&list) { + Some(appendable_value) => append_declaration_value(dest, appendable_value), + None => return Ok(()), + } + } + + /// Find the value of the given property in this block and serialize it + /// + /// <https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertyvalue> + pub fn property_value_to_css( + &self, + property: &PropertyId, + dest: &mut CssStringWriter, + ) -> fmt::Result { + // Step 1.1: done when parsing a string to PropertyId + + // Step 1.2 + let longhand_or_custom = match property.as_shorthand() { + Ok(shorthand) => return self.shorthand_to_css(shorthand, dest), + Err(longhand_or_custom) => longhand_or_custom, + }; + + if let Some((value, _importance)) = self.get(longhand_or_custom) { + // Step 2 + value.to_css(dest) + } else { + // Step 3 + Ok(()) + } + } + + /// <https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-getpropertypriority> + pub fn property_priority(&self, property: &PropertyId) -> Importance { + // Step 1: done when parsing a string to PropertyId + + // Step 2 + match property.as_shorthand() { + Ok(shorthand) => { + // Step 2.1 & 2.2 & 2.3 + if shorthand.longhands().all(|l| { + self.get(PropertyDeclarationId::Longhand(l)) + .map_or(false, |(_, importance)| importance.important()) + }) { + Importance::Important + } else { + Importance::Normal + } + }, + Err(longhand_or_custom) => { + // Step 3 + self.get(longhand_or_custom) + .map_or(Importance::Normal, |(_, importance)| importance) + }, + } + } + + /// Adds or overrides the declaration for a given property in this block. + /// + /// See the documentation of `push` to see what impact `source` has when the + /// property is already there. + pub fn extend( + &mut self, + mut drain: SourcePropertyDeclarationDrain, + importance: Importance, + ) -> bool { + let all_shorthand_len = match drain.all_shorthand { + AllShorthand::NotSet => 0, + AllShorthand::CSSWideKeyword(_) | AllShorthand::WithVariables(_) => { + shorthands::ALL_SHORTHAND_MAX_LEN + }, + }; + let push_calls_count = drain.declarations.len() + all_shorthand_len; + + // With deduplication the actual length increase may be less than this. + self.declarations.reserve(push_calls_count); + + let mut changed = false; + for decl in &mut drain.declarations { + changed |= self.push(decl, importance); + } + drain + .all_shorthand + .declarations() + .fold(changed, |changed, decl| { + changed | self.push(decl, importance) + }) + } + + /// Adds or overrides the declaration for a given property in this block. + /// + /// Returns whether the declaration has changed. + /// + /// This is only used for parsing and internal use. + pub fn push(&mut self, declaration: PropertyDeclaration, importance: Importance) -> bool { + let id = declaration.id(); + if !self.property_ids.insert(id) { + let mut index_to_remove = None; + for (i, slot) in self.declarations.iter_mut().enumerate() { + if slot.id() != id { + continue; + } + + let important = self.declarations_importance[i]; + + // For declarations from parsing, non-important declarations + // shouldn't override existing important one. + if important && !importance.important() { + return false; + } + + index_to_remove = Some(i); + break; + } + + if let Some(index) = index_to_remove { + self.declarations.remove(index); + self.declarations_importance.remove(index); + self.declarations.push(declaration); + self.declarations_importance.push(importance.important()); + return true; + } + } + + self.declarations.push(declaration); + self.declarations_importance.push(importance.important()); + true + } + + /// Prepares updating this declaration block with the given + /// `SourcePropertyDeclaration` and importance, and returns whether + /// there is something to update. + pub fn prepare_for_update( + &self, + source_declarations: &SourcePropertyDeclaration, + importance: Importance, + updates: &mut SourcePropertyDeclarationUpdate, + ) -> bool { + debug_assert!(updates.updates.is_empty()); + // Check whether we are updating for an all shorthand change. + if !matches!(source_declarations.all_shorthand, AllShorthand::NotSet) { + debug_assert!(source_declarations.declarations.is_empty()); + return source_declarations + .all_shorthand + .declarations() + .any(|decl| { + !self.contains(decl.id()) || + self.declarations + .iter() + .enumerate() + .find(|&(_, ref d)| d.id() == decl.id()) + .map_or(true, |(i, d)| { + let important = self.declarations_importance[i]; + *d != decl || important != importance.important() + }) + }); + } + // Fill `updates` with update information. + let mut any_update = false; + let new_count = &mut updates.new_count; + let any_removal = &mut updates.any_removal; + let updates = &mut updates.updates; + updates.extend( + source_declarations + .declarations + .iter() + .map(|declaration| { + if !self.contains(declaration.id()) { + return DeclarationUpdate::Append; + } + let longhand_id = declaration.id().as_longhand(); + if let Some(longhand_id) = longhand_id { + if let Some(logical_group) = longhand_id.logical_group() { + let mut needs_append = false; + for (pos, decl) in self.declarations.iter().enumerate().rev() { + let id = match decl.id().as_longhand() { + Some(id) => id, + None => continue, + }; + if id == longhand_id { + if needs_append { + return DeclarationUpdate::AppendAndRemove { pos }; + } + let important = self.declarations_importance[pos]; + if decl == declaration && important == importance.important() { + return DeclarationUpdate::None; + } + return DeclarationUpdate::UpdateInPlace { pos }; + } + if !needs_append && + id.logical_group() == Some(logical_group) && + id.is_logical() != longhand_id.is_logical() + { + needs_append = true; + } + } + unreachable!("Longhand should be found in loop above"); + } + } + self.declarations + .iter() + .enumerate() + .find(|&(_, ref decl)| decl.id() == declaration.id()) + .map_or(DeclarationUpdate::Append, |(pos, decl)| { + let important = self.declarations_importance[pos]; + if decl == declaration && important == importance.important() { + DeclarationUpdate::None + } else { + DeclarationUpdate::UpdateInPlace { pos } + } + }) + }) + .inspect(|update| { + if matches!(update, DeclarationUpdate::None) { + return; + } + any_update = true; + match update { + DeclarationUpdate::Append => { + *new_count += 1; + }, + DeclarationUpdate::AppendAndRemove { .. } => { + *any_removal = true; + }, + _ => {}, + } + }), + ); + any_update + } + + /// Update this declaration block with the given data. + pub fn update( + &mut self, + drain: SourcePropertyDeclarationDrain, + importance: Importance, + updates: &mut SourcePropertyDeclarationUpdate, + ) { + let important = importance.important(); + if !matches!(drain.all_shorthand, AllShorthand::NotSet) { + debug_assert!(updates.updates.is_empty()); + for decl in drain.all_shorthand.declarations() { + let id = decl.id(); + if self.property_ids.insert(id) { + self.declarations.push(decl); + self.declarations_importance.push(important); + } else { + let (idx, slot) = self + .declarations + .iter_mut() + .enumerate() + .find(|&(_, ref d)| d.id() == decl.id()) + .unwrap(); + *slot = decl; + self.declarations_importance.set(idx, important); + } + } + return; + } + + self.declarations.reserve(updates.new_count); + if updates.any_removal { + // Prepare for removal and fixing update positions. + struct UpdateOrRemoval<'a> { + item: &'a mut DeclarationUpdate, + pos: usize, + remove: bool, + } + let mut updates_and_removals: SubpropertiesVec<UpdateOrRemoval> = updates + .updates + .iter_mut() + .filter_map(|item| { + let (pos, remove) = match *item { + DeclarationUpdate::UpdateInPlace { pos } => (pos, false), + DeclarationUpdate::AppendAndRemove { pos } => (pos, true), + _ => return None, + }; + Some(UpdateOrRemoval { item, pos, remove }) + }) + .collect(); + // Execute removals. It's important to do it in reverse index order, + // so that removing doesn't invalidate following positions. + updates_and_removals.sort_unstable_by_key(|update| update.pos); + updates_and_removals + .iter() + .rev() + .filter(|update| update.remove) + .for_each(|update| { + self.declarations.remove(update.pos); + self.declarations_importance.remove(update.pos); + }); + // Fixup pos field for updates. + let mut removed_count = 0; + for update in updates_and_removals.iter_mut() { + if update.remove { + removed_count += 1; + continue; + } + debug_assert_eq!( + *update.item, + DeclarationUpdate::UpdateInPlace { pos: update.pos } + ); + *update.item = DeclarationUpdate::UpdateInPlace { + pos: update.pos - removed_count, + }; + } + } + // Execute updates and appends. + for (decl, update) in drain.declarations.zip_eq(updates.updates.iter()) { + match *update { + DeclarationUpdate::None => {}, + DeclarationUpdate::Append | DeclarationUpdate::AppendAndRemove { .. } => { + self.property_ids.insert(decl.id()); + self.declarations.push(decl); + self.declarations_importance.push(important); + }, + DeclarationUpdate::UpdateInPlace { pos } => { + self.declarations[pos] = decl; + self.declarations_importance.set(pos, important); + }, + } + } + updates.updates.clear(); + } + + /// Returns the first declaration that would be removed by removing + /// `property`. + #[inline] + pub fn first_declaration_to_remove(&self, property: &PropertyId) -> Option<usize> { + if let Err(longhand_or_custom) = property.as_shorthand() { + if !self.contains(longhand_or_custom) { + return None; + } + } + + self.declarations + .iter() + .position(|declaration| declaration.id().is_or_is_longhand_of(property)) + } + + /// Removes a given declaration at a given index. + #[inline] + fn remove_declaration_at(&mut self, i: usize) { + self.property_ids.remove(self.declarations[i].id()); + self.declarations_importance.remove(i); + self.declarations.remove(i); + } + + /// Clears all the declarations from this block. + #[inline] + pub fn clear(&mut self) { + self.declarations_importance.clear(); + self.declarations.clear(); + self.property_ids.clear(); + } + + /// <https://drafts.csswg.org/cssom/#dom-cssstyledeclaration-removeproperty> + /// + /// `first_declaration` needs to be the result of + /// `first_declaration_to_remove`. + #[inline] + pub fn remove_property(&mut self, property: &PropertyId, first_declaration: usize) { + debug_assert_eq!( + Some(first_declaration), + self.first_declaration_to_remove(property) + ); + debug_assert!(self.declarations[first_declaration] + .id() + .is_or_is_longhand_of(property)); + + self.remove_declaration_at(first_declaration); + + let shorthand = match property.as_shorthand() { + Ok(s) => s, + Err(_longhand_or_custom) => return, + }; + + let mut i = first_declaration; + let mut len = self.len(); + while i < len { + if !self.declarations[i].id().is_longhand_of(shorthand) { + i += 1; + continue; + } + + self.remove_declaration_at(i); + len -= 1; + } + } + + /// Take a declaration block known to contain a single property and serialize it. + pub fn single_value_to_css( + &self, + property: &PropertyId, + dest: &mut CssStringWriter, + computed_values: Option<&ComputedValues>, + custom_properties_block: Option<&PropertyDeclarationBlock>, + device: &Device, + ) -> fmt::Result { + if let Ok(shorthand) = property.as_shorthand() { + return self.shorthand_to_css(shorthand, dest); + } + + // FIXME(emilio): Should this assert, or assert that the declaration is + // the property we expect? + let declaration = match self.declarations.get(0) { + Some(d) => d, + None => return Err(fmt::Error), + }; + + let custom_properties = if let Some(cv) = computed_values { + // If there are extra custom properties for this declaration block, + // factor them in too. + if let Some(block) = custom_properties_block { + // FIXME(emilio): This is not super-efficient here, and all this + // feels like a hack anyway... + block.cascade_custom_properties(cv.custom_properties(), device) + } else { + cv.custom_properties().cloned() + } + } else { + None + }; + + match (declaration, computed_values) { + // If we have a longhand declaration with variables, those variables + // will be stored as unparsed values. + // + // As a temporary measure to produce sensible results in Gecko's + // getKeyframes() implementation for CSS animations, if + // |computed_values| is supplied, we use it to expand such variable + // declarations. This will be fixed properly in Gecko bug 1391537. + (&PropertyDeclaration::WithVariables(ref declaration), Some(ref computed_values)) => { + declaration + .value + .substitute_variables( + declaration.id, + computed_values.writing_mode, + custom_properties.as_ref(), + QuirksMode::NoQuirks, + device, + &mut Default::default(), + ) + .to_css(dest) + }, + (ref d, _) => d.to_css(dest), + } + } + + /// Convert AnimationValueMap to PropertyDeclarationBlock. + pub fn from_animation_value_map(animation_value_map: &AnimationValueMap) -> Self { + let len = animation_value_map.len(); + let mut declarations = ThinVec::with_capacity(len); + let mut property_ids = PropertyDeclarationIdSet::default(); + + for (property, animation_value) in animation_value_map.iter() { + property_ids.longhands.insert(*property); + declarations.push(animation_value.uncompute()); + } + + PropertyDeclarationBlock { + declarations, + property_ids, + declarations_importance: SmallBitVec::from_elem(len, false), + } + } + + /// Returns true if the declaration block has a CSSWideKeyword for the given + /// property. + pub fn has_css_wide_keyword(&self, property: &PropertyId) -> bool { + if let Err(longhand_or_custom) = property.as_shorthand() { + if !self.property_ids.contains(longhand_or_custom) { + return false; + } + } + self.declarations.iter().any(|decl| { + decl.id().is_or_is_longhand_of(property) && decl.get_css_wide_keyword().is_some() + }) + } + + /// Returns a custom properties map which is the result of cascading custom + /// properties in this declaration block along with context's custom + /// properties. + pub fn cascade_custom_properties_with_context( + &self, + context: &Context, + ) -> Option<Arc<crate::custom_properties::CustomPropertiesMap>> { + self.cascade_custom_properties(context.style().custom_properties(), context.device()) + } + + /// Returns a custom properties map which is the result of cascading custom + /// properties in this declaration block along with the given custom + /// properties. + fn cascade_custom_properties( + &self, + inherited_custom_properties: Option<&Arc<crate::custom_properties::CustomPropertiesMap>>, + device: &Device, + ) -> Option<Arc<crate::custom_properties::CustomPropertiesMap>> { + let mut builder = CustomPropertiesBuilder::new(inherited_custom_properties, device); + + for declaration in self.normal_declaration_iter() { + if let PropertyDeclaration::Custom(ref declaration) = *declaration { + builder.cascade( + declaration, + CascadePriority::new( + CascadeLevel::same_tree_author_normal(), + LayerOrder::root(), + ), + ); + } + } + + builder.build() + } + + /// Like the method on ToCss, but without the type parameter to avoid + /// accidentally monomorphizing this large function multiple times for + /// different writers. + /// + /// https://drafts.csswg.org/cssom/#serialize-a-css-declaration-block + pub fn to_css(&self, dest: &mut CssStringWriter) -> fmt::Result { + let mut is_first_serialization = true; // trailing serializations should have a prepended space + + // Step 1 -> dest = result list + + // Step 2 + // + // NOTE(emilio): We reuse this set for both longhands and shorthands + // with subtly different meaning. For longhands, only longhands that + // have actually been serialized (either by themselves, or as part of a + // shorthand) appear here. For shorthands, all the shorthands that we've + // attempted to serialize appear here. + let mut already_serialized = NonCustomPropertyIdSet::new(); + + // Step 3 + 'declaration_loop: for (declaration, importance) in self.declaration_importance_iter() { + // Step 3.1 + let property = declaration.id(); + let longhand_id = match property { + PropertyDeclarationId::Longhand(id) => id, + PropertyDeclarationId::Custom(..) => { + // Given the invariants that there are no duplicate + // properties in a declaration block, and that custom + // properties can't be part of a shorthand, we can just care + // about them here. + append_serialization( + dest, + &property, + AppendableValue::Declaration(declaration), + importance, + &mut is_first_serialization, + )?; + continue; + }, + }; + + // Step 3.2 + if already_serialized.contains(longhand_id.into()) { + continue; + } + + // Steps 3.3 & 3.4 + for shorthand in longhand_id.shorthands() { + // We already attempted to serialize this shorthand before. + if already_serialized.contains(shorthand.into()) { + continue; + } + already_serialized.insert(shorthand.into()); + + if shorthand.is_legacy_shorthand() { + continue; + } + + // Step 3.3.1: + // Let longhands be an array consisting of all CSS + // declarations in declaration block’s declarations that + // that are not in already serialized and have a property + // name that maps to one of the shorthand properties in + // shorthands. + let longhands = { + // TODO(emilio): This could just index in an array if we + // remove pref-controlled longhands. + let mut ids = LonghandIdSet::new(); + for longhand in shorthand.longhands() { + ids.insert(longhand); + } + ids + }; + + // Step 3.4.2 + // If all properties that map to shorthand are not present + // in longhands, continue with the steps labeled shorthand + // loop. + if !self.property_ids.longhands.contains_all(&longhands) { + continue; + } + + // Step 3.4.3: + // Let current longhands be an empty array. + let mut current_longhands = SmallVec::<[&_; 10]>::new(); + let mut logical_groups = LogicalGroupSet::new(); + let mut saw_one = false; + let mut logical_mismatch = false; + let mut seen = LonghandIdSet::new(); + let mut important_count = 0; + + // Step 3.4.4: + // Append all CSS declarations in longhands that have a + // property name that maps to shorthand to current longhands. + for (declaration, importance) in self.declaration_importance_iter() { + let longhand = match declaration.id() { + PropertyDeclarationId::Longhand(id) => id, + PropertyDeclarationId::Custom(..) => continue, + }; + + if longhands.contains(longhand) { + saw_one = true; + if importance.important() { + important_count += 1; + } + current_longhands.push(declaration); + if shorthand != ShorthandId::All { + // All is special because it contains both physical + // and logical longhands. + if let Some(g) = longhand.logical_group() { + logical_groups.insert(g); + } + seen.insert(longhand); + if seen == longhands { + break; + } + } + } else if saw_one { + if let Some(g) = longhand.logical_group() { + if logical_groups.contains(g) { + logical_mismatch = true; + break; + } + } + } + } + + // 3.4.5: + // If there is one or more CSS declarations in current + // longhands have their important flag set and one or more + // with it unset, continue with the steps labeled shorthand + // loop. + let is_important = important_count > 0; + if is_important && important_count != current_longhands.len() { + continue; + } + + // 3.4.6: + // If there’s any declaration in declaration block in between + // the first and the last longhand in current longhands which + // belongs to the same logical property group, but has a + // different mapping logic as any of the longhands in current + // longhands, and is not in current longhands, continue with + // the steps labeled shorthand loop. + if logical_mismatch { + continue; + } + + let importance = if is_important { + Importance::Important + } else { + Importance::Normal + }; + + // 3.4.7: + // Let value be the result of invoking serialize a CSS value + // of current longhands. + let appendable_value = + match shorthand.get_shorthand_appendable_value(¤t_longhands) { + None => continue, + Some(appendable_value) => appendable_value, + }; + + // We avoid re-serializing if we're already an + // AppendableValue::Css. + let mut v = CssString::new(); + let value = match appendable_value { + AppendableValue::Css(css) => { + debug_assert!(!css.is_empty()); + appendable_value + }, + other => { + append_declaration_value(&mut v, other)?; + + // 3.4.8: + // If value is the empty string, continue with the + // steps labeled shorthand loop. + if v.is_empty() { + continue; + } + + AppendableValue::Css({ + // Safety: serialization only generates valid utf-8. + #[cfg(feature = "gecko")] + unsafe { + v.as_str_unchecked() + } + #[cfg(feature = "servo")] + &v + }) + }, + }; + + // 3.4.9: + // Let serialized declaration be the result of invoking + // serialize a CSS declaration with property name shorthand, + // value value, and the important flag set if the CSS + // declarations in current longhands have their important + // flag set. + // + // 3.4.10: + // Append serialized declaration to list. + append_serialization( + dest, + &shorthand, + value, + importance, + &mut is_first_serialization, + )?; + + // 3.4.11: + // Append the property names of all items of current + // longhands to already serialized. + for current_longhand in ¤t_longhands { + let longhand_id = match current_longhand.id() { + PropertyDeclarationId::Longhand(id) => id, + PropertyDeclarationId::Custom(..) => unreachable!(), + }; + + // Substep 9 + already_serialized.insert(longhand_id.into()); + } + + // 3.4.12: + // Continue with the steps labeled declaration loop. + continue 'declaration_loop; + } + + // Steps 3.5, 3.6 & 3.7: + // Let value be the result of invoking serialize a CSS value of + // declaration. + // + // Let serialized declaration be the result of invoking + // serialize a CSS declaration with property name property, + // value value, and the important flag set if declaration has + // its important flag set. + // + // Append serialized declaration to list. + append_serialization( + dest, + &property, + AppendableValue::Declaration(declaration), + importance, + &mut is_first_serialization, + )?; + + // Step 3.8: + // Append property to already serialized. + already_serialized.insert(longhand_id.into()); + } + + // Step 4 + Ok(()) + } +} + +/// A convenient enum to represent different kinds of stuff that can represent a +/// _value_ in the serialization of a property declaration. +pub enum AppendableValue<'a, 'b: 'a> { + /// A given declaration, of which we'll serialize just the value. + Declaration(&'a PropertyDeclaration), + /// A set of declarations for a given shorthand. + /// + /// FIXME: This needs more docs, where are the shorthands expanded? We print + /// the property name before-hand, don't we? + DeclarationsForShorthand(ShorthandId, &'a [&'b PropertyDeclaration]), + /// A raw CSS string, coming for example from a property with CSS variables, + /// or when storing a serialized shorthand value before appending directly. + Css(&'a str), +} + +/// Potentially appends whitespace after the first (property: value;) pair. +fn handle_first_serialization<W>(dest: &mut W, is_first_serialization: &mut bool) -> fmt::Result +where + W: Write, +{ + if !*is_first_serialization { + dest.write_char(' ') + } else { + *is_first_serialization = false; + Ok(()) + } +} + +/// Append a given kind of appendable value to a serialization. +pub fn append_declaration_value<'a, 'b: 'a>( + dest: &mut CssStringWriter, + appendable_value: AppendableValue<'a, 'b>, +) -> fmt::Result { + match appendable_value { + AppendableValue::Css(css) => dest.write_str(css), + AppendableValue::Declaration(decl) => decl.to_css(dest), + AppendableValue::DeclarationsForShorthand(shorthand, decls) => { + shorthand.longhands_to_css(decls, dest) + }, + } +} + +/// Append a given property and value pair to a serialization. +pub fn append_serialization<'a, 'b: 'a, N>( + dest: &mut CssStringWriter, + property_name: &N, + appendable_value: AppendableValue<'a, 'b>, + importance: Importance, + is_first_serialization: &mut bool, +) -> fmt::Result +where + N: ToCss, +{ + handle_first_serialization(dest, is_first_serialization)?; + + property_name.to_css(&mut CssWriter::new(dest))?; + dest.write_str(": ")?; + + append_declaration_value(dest, appendable_value)?; + + if importance.important() { + dest.write_str(" !important")?; + } + + dest.write_char(';') +} + +/// A helper to parse the style attribute of an element, in order for this to be +/// shared between Servo and Gecko. +/// +/// Inline because we call this cross-crate. +#[inline] +pub fn parse_style_attribute( + input: &str, + url_data: &UrlExtraData, + error_reporter: Option<&dyn ParseErrorReporter>, + quirks_mode: QuirksMode, + rule_type: CssRuleType, +) -> PropertyDeclarationBlock { + let context = ParserContext::new( + Origin::Author, + url_data, + Some(rule_type), + ParsingMode::DEFAULT, + quirks_mode, + /* namespaces = */ Default::default(), + error_reporter, + None, + ); + + let mut input = ParserInput::new(input); + parse_property_declaration_list(&context, &mut Parser::new(&mut input), None) +} + +/// Parse a given property declaration. Can result in multiple +/// `PropertyDeclaration`s when expanding a shorthand, for example. +/// +/// This does not attempt to parse !important at all. +#[inline] +pub fn parse_one_declaration_into( + declarations: &mut SourcePropertyDeclaration, + id: PropertyId, + input: &str, + origin: Origin, + url_data: &UrlExtraData, + error_reporter: Option<&dyn ParseErrorReporter>, + parsing_mode: ParsingMode, + quirks_mode: QuirksMode, + rule_type: CssRuleType, +) -> Result<(), ()> { + let context = ParserContext::new( + origin, + url_data, + Some(rule_type), + parsing_mode, + quirks_mode, + /* namespaces = */ Default::default(), + error_reporter, + None, + ); + + let property_id_for_error_reporting = if context.error_reporting_enabled() { + Some(id.clone()) + } else { + None + }; + + let mut input = ParserInput::new(input); + let mut parser = Parser::new(&mut input); + let start_position = parser.position(); + parser + .parse_entirely(|parser| { + PropertyDeclaration::parse_into(declarations, id, &context, parser) + }) + .map_err(|err| { + if context.error_reporting_enabled() { + report_one_css_error( + &context, + None, + None, + err, + parser.slice_from(start_position), + property_id_for_error_reporting, + ) + } + }) +} + +/// A struct to parse property declarations. +struct PropertyDeclarationParser<'a, 'b: 'a, 'i> { + context: &'a ParserContext<'b>, + state: &'a mut DeclarationParserState<'i>, +} + +/// The state needed to parse a declaration block. +/// +/// It stores declarations in output_block. +#[derive(Default)] +pub struct DeclarationParserState<'i> { + /// The output block where results are stored. + output_block: PropertyDeclarationBlock, + /// Declarations from the last declaration parsed. (note that a shorthand might expand to + /// multiple declarations). + declarations: SourcePropertyDeclaration, + /// The importance from the last declaration parsed. + importance: Importance, + /// A list of errors that have happened so far. Not all of them might be reported. + errors: SmallParseErrorVec<'i>, + /// The last parsed property id, if any. + last_parsed_property_id: Option<PropertyId>, +} + +impl<'i> DeclarationParserState<'i> { + /// Returns whether any parsed declarations have been parsed so far. + pub fn has_parsed_declarations(&self) -> bool { + !self.output_block.is_empty() + } + + /// Takes the parsed declarations. + pub fn take_declarations(&mut self) -> PropertyDeclarationBlock { + std::mem::take(&mut self.output_block) + } + + /// Parse a single declaration value. + pub fn parse_value<'t>( + &mut self, + context: &ParserContext, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<(), ParseError<'i>> { + let id = match PropertyId::parse(&name, context) { + Ok(id) => id, + Err(..) => { + return Err(input.new_custom_error(StyleParseErrorKind::UnknownProperty(name))); + }, + }; + if context.error_reporting_enabled() { + self.last_parsed_property_id = Some(id.clone()); + } + input.parse_until_before(Delimiter::Bang, |input| { + PropertyDeclaration::parse_into(&mut self.declarations, id, context, input) + })?; + self.importance = match input.try_parse(parse_important) { + Ok(()) => Importance::Important, + Err(_) => Importance::Normal, + }; + // In case there is still unparsed text in the declaration, we should roll back. + input.expect_exhausted()?; + self.output_block + .extend(self.declarations.drain(), self.importance); + // We've successfully parsed a declaration, so forget about + // `last_parsed_property_id`. It'd be wrong to associate any + // following error with this property. + self.last_parsed_property_id = None; + Ok(()) + } + + /// Reports any CSS errors that have ocurred if needed. + #[inline] + pub fn report_errors_if_needed( + &mut self, + context: &ParserContext, + selectors: Option<&SelectorList<SelectorImpl>>, + ) { + if self.errors.is_empty() { + return; + } + self.do_report_css_errors(context, selectors); + } + + #[cold] + fn do_report_css_errors( + &mut self, + context: &ParserContext, + selectors: Option<&SelectorList<SelectorImpl>>, + ) { + for (error, slice, property) in self.errors.drain(..) { + report_one_css_error( + context, + Some(&self.output_block), + selectors, + error, + slice, + property, + ) + } + } + + /// Resets the declaration parser state, and reports the error if needed. + #[inline] + pub fn did_error(&mut self, context: &ParserContext, error: ParseError<'i>, slice: &'i str) { + self.declarations.clear(); + if !context.error_reporting_enabled() { + return; + } + let property = self.last_parsed_property_id.take(); + self.errors.push((error, slice, property)); + } +} + +/// Default methods reject all at rules. +impl<'a, 'b, 'i> AtRuleParser<'i> for PropertyDeclarationParser<'a, 'b, 'i> { + type Prelude = (); + type AtRule = (); + type Error = StyleParseErrorKind<'i>; +} + +/// Default methods reject all rules. +impl<'a, 'b, 'i> QualifiedRuleParser<'i> for PropertyDeclarationParser<'a, 'b, 'i> { + type Prelude = (); + type QualifiedRule = (); + type Error = StyleParseErrorKind<'i>; +} + +/// Based on NonMozillaVendorIdentifier from Gecko's CSS parser. +fn is_non_mozilla_vendor_identifier(name: &str) -> bool { + (name.starts_with("-") && !name.starts_with("-moz-")) || name.starts_with("_") +} + +impl<'a, 'b, 'i> DeclarationParser<'i> for PropertyDeclarationParser<'a, 'b, 'i> { + type Declaration = (); + type Error = StyleParseErrorKind<'i>; + + fn parse_value<'t>( + &mut self, + name: CowRcStr<'i>, + input: &mut Parser<'i, 't>, + ) -> Result<(), ParseError<'i>> { + self.state.parse_value(self.context, name, input) + } +} + +impl<'a, 'b, 'i> RuleBodyItemParser<'i, (), StyleParseErrorKind<'i>> + for PropertyDeclarationParser<'a, 'b, 'i> +{ + fn parse_declarations(&self) -> bool { + true + } + // TODO(emilio): Nesting. + fn parse_qualified(&self) -> bool { + false + } +} + +type SmallParseErrorVec<'i> = SmallVec<[(ParseError<'i>, &'i str, Option<PropertyId>); 2]>; + +fn alias_of_known_property(name: &str) -> Option<PropertyId> { + let mut prefixed = String::with_capacity(name.len() + 5); + prefixed.push_str("-moz-"); + prefixed.push_str(name); + PropertyId::parse_enabled_for_all_content(&prefixed).ok() +} + +#[cold] +fn report_one_css_error<'i>( + context: &ParserContext, + block: Option<&PropertyDeclarationBlock>, + selectors: Option<&SelectorList<SelectorImpl>>, + mut error: ParseError<'i>, + slice: &str, + property: Option<PropertyId>, +) { + debug_assert!(context.error_reporting_enabled()); + + fn all_properties_in_block(block: &PropertyDeclarationBlock, property: &PropertyId) -> bool { + match property.as_shorthand() { + Ok(id) => id + .longhands() + .all(|longhand| block.contains(PropertyDeclarationId::Longhand(longhand))), + Err(longhand_or_custom) => block.contains(longhand_or_custom), + } + } + + if let ParseErrorKind::Custom(StyleParseErrorKind::UnknownProperty(ref name)) = error.kind { + if is_non_mozilla_vendor_identifier(name) { + // If the unrecognized property looks like a vendor-specific property, + // silently ignore it instead of polluting the error output. + return; + } + if let Some(alias) = alias_of_known_property(name) { + // This is an unknown property, but its -moz-* version is known. + // We don't want to report error if the -moz-* version is already + // specified. + if let Some(block) = block { + if all_properties_in_block(block, &alias) { + return; + } + } + } + } + + if let Some(ref property) = property { + if let Some(block) = block { + if all_properties_in_block(block, property) { + return; + } + } + error = match *property { + PropertyId::Custom(ref c) => { + StyleParseErrorKind::new_invalid(format!("--{}", c), error) + }, + _ => StyleParseErrorKind::new_invalid(property.non_custom_id().unwrap().name(), error), + }; + } + + let location = error.location; + let error = ContextualParseError::UnsupportedPropertyDeclaration(slice, error, selectors); + context.log_css_error(location, error); +} + +/// Parse a list of property declarations and return a property declaration +/// block. +pub fn parse_property_declaration_list( + context: &ParserContext, + input: &mut Parser, + selectors: Option<&SelectorList<SelectorImpl>>, +) -> PropertyDeclarationBlock { + let mut state = DeclarationParserState::default(); + let mut parser = PropertyDeclarationParser { + context, + state: &mut state, + }; + let mut iter = RuleBodyParser::new(input, &mut parser); + while let Some(declaration) = iter.next() { + match declaration { + Ok(()) => {}, + Err((error, slice)) => iter.parser.state.did_error(context, error, slice), + } + } + parser.state.report_errors_if_needed(context, selectors); + state.output_block +} |