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

Move Arc<RwLock<_>> out from CssRules tuple

Browse source
This commit is contained in:
Xidorn Quan 2016-11-28 12:44:52 +11:00
parent 40917e7991
commit 599eb1c9f0
9 changed files with 58 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

9
components/script/dom/cssgroupingrule.rs
View file

@ -13,19 +13,21 @@ use dom::cssrule::CSSRule;
use dom::cssrulelist::{CSSRuleList, RulesSource}; use dom::cssrulelist::{CSSRuleList, RulesSource};
use dom::cssstylesheet::CSSStyleSheet; use dom::cssstylesheet::CSSStyleSheet;
use dom::window::Window; use dom::window::Window;
use parking_lot::RwLock;
use std::sync::Arc;
use style::stylesheets::CssRules as StyleCssRules; use style::stylesheets::CssRules as StyleCssRules;
#[dom_struct] #[dom_struct]
pub struct CSSGroupingRule { pub struct CSSGroupingRule {
cssrule: CSSRule, cssrule: CSSRule,
#[ignore_heap_size_of = "Arc"] #[ignore_heap_size_of = "Arc"]
rules: StyleCssRules, rules: Arc<RwLock<StyleCssRules>>,
rulelist: MutNullableHeap<JS<CSSRuleList>>, rulelist: MutNullableHeap<JS<CSSRuleList>>,
} }
impl CSSGroupingRule { impl CSSGroupingRule {
pub fn new_inherited(parent_stylesheet: &CSSStyleSheet, pub fn new_inherited(parent_stylesheet: &CSSStyleSheet,
rules: StyleCssRules) -> CSSGroupingRule { rules: Arc<RwLock<StyleCssRules>>) -> CSSGroupingRule {
CSSGroupingRule { CSSGroupingRule {
cssrule: CSSRule::new_inherited(parent_stylesheet), cssrule: CSSRule::new_inherited(parent_stylesheet),
rules: rules, rules: rules,
@ -34,7 +36,8 @@ impl CSSGroupingRule {
} }
#[allow(unrooted_must_root)] #[allow(unrooted_must_root)]
pub fn new(window: &Window, parent_stylesheet: &CSSStyleSheet, rules: StyleCssRules) -> Root<CSSGroupingRule> { pub fn new(window: &Window, parent_stylesheet: &CSSStyleSheet,
rules: Arc<RwLock<StyleCssRules>>) -> Root<CSSGroupingRule> {
reflect_dom_object(box CSSGroupingRule::new_inherited(parent_stylesheet, rules), reflect_dom_object(box CSSGroupingRule::new_inherited(parent_stylesheet, rules),
window, window,
CSSGroupingRuleBinding::Wrap) CSSGroupingRuleBinding::Wrap)

10
components/script/dom/cssrulelist.rs
View file

@ -41,7 +41,7 @@ pub struct CSSRuleList {
} }
pub enum RulesSource { pub enum RulesSource {
Rules(CssRules), Rules(Arc<RwLock<CssRules>>),
Keyframes(Arc<RwLock<KeyframesRule>>), Keyframes(Arc<RwLock<KeyframesRule>>),
} }
@ -50,7 +50,7 @@ impl CSSRuleList {
pub fn new_inherited(parent_stylesheet: &CSSStyleSheet, rules: RulesSource) -> CSSRuleList { pub fn new_inherited(parent_stylesheet: &CSSStyleSheet, rules: RulesSource) -> CSSRuleList {
let dom_rules = match rules { let dom_rules = match rules {
RulesSource::Rules(ref rules) => { RulesSource::Rules(ref rules) => {
rules.0.read().iter().map(|_| MutNullableHeap::new(None)).collect() rules.read().0.iter().map(|_| MutNullableHeap::new(None)).collect()
} }
RulesSource::Keyframes(ref rules) => { RulesSource::Keyframes(ref rules) => {
rules.read().keyframes.iter().map(|_| MutNullableHeap::new(None)).collect() rules.read().keyframes.iter().map(|_| MutNullableHeap::new(None)).collect()
@ -87,7 +87,7 @@ impl CSSRuleList {
let index = idx as usize; let index = idx as usize;
let parent_stylesheet = self.parent_stylesheet.style_stylesheet(); let parent_stylesheet = self.parent_stylesheet.style_stylesheet();
let new_rule = css_rules.insert_rule(rule, parent_stylesheet, index, nested)?; let new_rule = css_rules.write().insert_rule(rule, parent_stylesheet, index, nested)?;
let parent_stylesheet = &*self.parent_stylesheet; let parent_stylesheet = &*self.parent_stylesheet;
let dom_rule = CSSRule::new_specific(&window, parent_stylesheet, new_rule); let dom_rule = CSSRule::new_specific(&window, parent_stylesheet, new_rule);
@ -101,7 +101,7 @@ impl CSSRuleList {
match self.rules { match self.rules {
RulesSource::Rules(ref css_rules) => { RulesSource::Rules(ref css_rules) => {
css_rules.remove_rule(index)?; css_rules.write().remove_rule(index)?;
let mut dom_rules = self.dom_rules.borrow_mut(); let mut dom_rules = self.dom_rules.borrow_mut();
dom_rules[index].get().map(|r| r.detach()); dom_rules[index].get().map(|r| r.detach());
dom_rules.remove(index); dom_rules.remove(index);
@ -133,7 +133,7 @@ impl CSSRuleList {
RulesSource::Rules(ref rules) => { RulesSource::Rules(ref rules) => {
CSSRule::new_specific(self.global().as_window(), CSSRule::new_specific(self.global().as_window(),
parent_stylesheet, parent_stylesheet,
rules.0.read()[idx as usize].clone()) rules.read().0[idx as usize].clone())
} }
RulesSource::Keyframes(ref rules) => { RulesSource::Keyframes(ref rules) => {
Root::upcast(CSSKeyframeRule::new(self.global().as_window(), Root::upcast(CSSKeyframeRule::new(self.global().as_window(),

4
components/script/dom/htmlmetaelement.rs
View file

@ -24,7 +24,7 @@ use std::sync::Arc;
use std::sync::atomic::AtomicBool; use std::sync::atomic::AtomicBool;
use style::attr::AttrValue; use style::attr::AttrValue;
use style::str::HTML_SPACE_CHARACTERS; use style::str::HTML_SPACE_CHARACTERS;
use style::stylesheets::{Stylesheet, CssRule, Origin}; use style::stylesheets::{Stylesheet, CssRule, CssRules, Origin};
use style::viewport::ViewportRule; use style::viewport::ViewportRule;
#[dom_struct] #[dom_struct]
@ -98,7 +98,7 @@ impl HTMLMetaElement {
if !content.is_empty() { if !content.is_empty() {
if let Some(translated_rule) = ViewportRule::from_meta(&**content) { if let Some(translated_rule) = ViewportRule::from_meta(&**content) {
*self.stylesheet.borrow_mut() = Some(Arc::new(Stylesheet { *self.stylesheet.borrow_mut() = Some(Arc::new(Stylesheet {
rules: vec![CssRule::Viewport(Arc::new(RwLock::new(translated_rule)))].into(), rules: CssRules::new(vec![CssRule::Viewport(Arc::new(RwLock::new(translated_rule)))]),
origin: Origin::Author, origin: Origin::Author,
base_url: window_from_node(self).get_url(), base_url: window_from_node(self).get_url(),
namespaces: Default::default(), namespaces: Default::default(),

6
components/style/gecko/conversions.rs
View file

@ -18,7 +18,7 @@ use gecko_bindings::sugar::ns_style_coord::{CoordDataValue, CoordDataMut};
use gecko_bindings::sugar::ownership::{HasArcFFI, HasFFI}; use gecko_bindings::sugar::ownership::{HasArcFFI, HasFFI};
use parking_lot::RwLock; use parking_lot::RwLock;
use properties::{ComputedValues, PropertyDeclarationBlock}; use properties::{ComputedValues, PropertyDeclarationBlock};
use stylesheets::{CssRule, Stylesheet, StyleRule}; use stylesheets::{CssRules, Stylesheet, StyleRule};
use values::computed::{CalcLengthOrPercentage, Gradient, Image, LengthOrPercentage, LengthOrPercentageOrAuto}; use values::computed::{CalcLengthOrPercentage, Gradient, Image, LengthOrPercentage, LengthOrPercentageOrAuto};
unsafe impl HasFFI for Stylesheet { unsafe impl HasFFI for Stylesheet {
@ -35,10 +35,10 @@ unsafe impl HasFFI for RwLock<PropertyDeclarationBlock> {
} }
unsafe impl HasArcFFI for RwLock<PropertyDeclarationBlock> {} unsafe impl HasArcFFI for RwLock<PropertyDeclarationBlock> {}
unsafe impl HasFFI for RwLock<Vec<CssRule>> { unsafe impl HasFFI for RwLock<CssRules> {
type FFIType = ServoCssRules; type FFIType = ServoCssRules;
} }
unsafe impl HasArcFFI for RwLock<Vec<CssRule>> {} unsafe impl HasArcFFI for RwLock<CssRules> {}
unsafe impl HasFFI for RwLock<StyleRule> { unsafe impl HasFFI for RwLock<StyleRule> {
type FFIType = RawServoStyleRule; type FFIType = RawServoStyleRule;

63
components/style/stylesheets.rs
View file

@ -51,14 +51,8 @@ pub struct Namespaces {
pub prefixes: FnvHashMap<Prefix , Namespace>, pub prefixes: FnvHashMap<Prefix , Namespace>,
} }
#[derive(Debug, Clone)] #[derive(Debug)]
pub struct CssRules(pub Arc<RwLock<Vec<CssRule>>>); pub struct CssRules(pub Vec<CssRule>);
impl From<Vec<CssRule>> for CssRules {
fn from(other: Vec<CssRule>) -> Self {
CssRules(Arc::new(RwLock::new(other)))
}
}
pub enum RulesMutateError { pub enum RulesMutateError {
Syntax, Syntax,
@ -77,9 +71,12 @@ impl From<SingleRuleParseError> for RulesMutateError {
} }
impl CssRules { impl CssRules {
// used in CSSOM pub fn new(rules: Vec<CssRule>) -> Arc<RwLock<CssRules>> {
pub fn only_ns_or_import(rules: &[CssRule]) -> bool { Arc::new(RwLock::new(CssRules(rules)))
rules.iter().all(|r| { }
fn only_ns_or_import(&self) -> bool {
self.0.iter().all(|r| {
match *r { match *r {
CssRule::Namespace(..) /* | CssRule::Import(..) */ => true, CssRule::Namespace(..) /* | CssRule::Import(..) */ => true,
_ => false _ => false
@ -88,12 +85,10 @@ impl CssRules {
} }
// https://drafts.csswg.org/cssom/#insert-a-css-rule // https://drafts.csswg.org/cssom/#insert-a-css-rule
pub fn insert_rule(&self, rule: &str, parent_stylesheet: &Stylesheet, index: usize, nested: bool) pub fn insert_rule(&mut self, rule: &str, parent_stylesheet: &Stylesheet, index: usize, nested: bool)
-> Result<CssRule, RulesMutateError> { -> Result<CssRule, RulesMutateError> {
let mut rules = self.0.write();
// Step 1, 2 // Step 1, 2
if index > rules.len() { if index > self.0.len() {
return Err(RulesMutateError::IndexSize); return Err(RulesMutateError::IndexSize);
} }
@ -103,7 +98,7 @@ impl CssRules {
} else if index == 0 { } else if index == 0 {
Some(State::Start) Some(State::Start)
} else { } else {
rules.get(index - 1).map(CssRule::rule_state) self.0.get(index - 1).map(CssRule::rule_state)
}; };
// Step 3, 4 // Step 3, 4
@ -113,7 +108,7 @@ impl CssRules {
// Step 5 // Step 5
// Computes the maximum allowed parser state at a given index. // Computes the maximum allowed parser state at a given index.
let rev_state = rules.get(index).map_or(State::Body, CssRule::rule_state); let rev_state = self.0.get(index).map_or(State::Body, CssRule::rule_state);
if new_state > rev_state { if new_state > rev_state {
// We inserted a rule too early, e.g. inserting // We inserted a rule too early, e.g. inserting
// a regular style rule before @namespace rules // a regular style rule before @namespace rules
@ -122,38 +117,36 @@ impl CssRules {
// Step 6 // Step 6
if let CssRule::Namespace(..) = new_rule { if let CssRule::Namespace(..) = new_rule {
if !CssRules::only_ns_or_import(&rules) { if !self.only_ns_or_import() {
return Err(RulesMutateError::InvalidState); return Err(RulesMutateError::InvalidState);
} }
} }
rules.insert(index, new_rule.clone()); self.0.insert(index, new_rule.clone());
Ok(new_rule) Ok(new_rule)
} }
// https://drafts.csswg.org/cssom/#remove-a-css-rule // https://drafts.csswg.org/cssom/#remove-a-css-rule
pub fn remove_rule(&self, index: usize) -> Result<(), RulesMutateError> { pub fn remove_rule(&mut self, index: usize) -> Result<(), RulesMutateError> {
let mut rules = self.0.write();
// Step 1, 2 // Step 1, 2
if index >= rules.len() { if index >= self.0.len() {
return Err(RulesMutateError::IndexSize); return Err(RulesMutateError::IndexSize);
} }
{ {
// Step 3 // Step 3
let ref rule = rules[index]; let ref rule = self.0[index];
// Step 4 // Step 4
if let CssRule::Namespace(..) = *rule { if let CssRule::Namespace(..) = *rule {
if !CssRules::only_ns_or_import(&rules) { if !self.only_ns_or_import() {
return Err(RulesMutateError::InvalidState); return Err(RulesMutateError::InvalidState);
} }
} }
} }
// Step 5, 6 // Step 5, 6
rules.remove(index); self.0.remove(index);
Ok(()) Ok(())
} }
} }
@ -162,7 +155,7 @@ impl CssRules {
pub struct Stylesheet { pub struct Stylesheet {
/// List of rules in the order they were found (important for /// List of rules in the order they were found (important for
/// cascading order) /// cascading order)
pub rules: CssRules, pub rules: Arc<RwLock<CssRules>>,
/// List of media associated with the Stylesheet. /// List of media associated with the Stylesheet.
pub media: Arc<RwLock<MediaList>>, pub media: Arc<RwLock<MediaList>>,
pub origin: Origin, pub origin: Origin,
@ -274,8 +267,8 @@ impl CssRule {
CssRule::Media(ref lock) => { CssRule::Media(ref lock) => {
let media_rule = lock.read(); let media_rule = lock.read();
let mq = media_rule.media_queries.read(); let mq = media_rule.media_queries.read();
let rules = media_rule.rules.0.read(); let rules = &media_rule.rules.read().0;
f(&rules, Some(&mq)) f(rules, Some(&mq))
} }
} }
} }
@ -376,7 +369,7 @@ impl ToCss for KeyframesRule {
#[derive(Debug)] #[derive(Debug)]
pub struct MediaRule { pub struct MediaRule {
pub media_queries: Arc<RwLock<MediaList>>, pub media_queries: Arc<RwLock<MediaList>>,
pub rules: CssRules, pub rules: Arc<RwLock<CssRules>>,
} }
impl ToCss for MediaRule { impl ToCss for MediaRule {
@ -386,7 +379,7 @@ impl ToCss for MediaRule {
try!(dest.write_str("@media (")); try!(dest.write_str("@media ("));
try!(self.media_queries.read().to_css(dest)); try!(self.media_queries.read().to_css(dest));
try!(dest.write_str(") {")); try!(dest.write_str(") {"));
for rule in self.rules.0.read().iter() { for rule in self.rules.read().0.iter() {
try!(dest.write_str(" ")); try!(dest.write_str(" "));
try!(rule.to_css(dest)); try!(rule.to_css(dest));
} }
@ -470,7 +463,7 @@ impl Stylesheet {
origin: origin, origin: origin,
base_url: base_url, base_url: base_url,
namespaces: RwLock::new(namespaces), namespaces: RwLock::new(namespaces),
rules: rules.into(), rules: CssRules::new(rules),
media: Arc::new(RwLock::new(media)), media: Arc::new(RwLock::new(media)),
dirty_on_viewport_size_change: AtomicBool::new(dirty_on_viewport_size_change), dirty_on_viewport_size_change: AtomicBool::new(dirty_on_viewport_size_change),
disabled: AtomicBool::new(false), disabled: AtomicBool::new(false),
@ -512,7 +505,7 @@ impl Stylesheet {
/// examined. /// examined.
#[inline] #[inline]
pub fn effective_rules<F>(&self, device: &Device, mut f: F) where F: FnMut(&CssRule) { pub fn effective_rules<F>(&self, device: &Device, mut f: F) where F: FnMut(&CssRule) {
effective_rules(&self.rules.0.read(), device, &mut f); effective_rules(&self.rules.read().0, device, &mut f);
} }
/// Returns whether the stylesheet has been explicitly disabled through the CSSOM. /// Returns whether the stylesheet has been explicitly disabled through the CSSOM.
@ -698,7 +691,7 @@ struct NestedRuleParser<'a, 'b: 'a> {
} }
impl<'a, 'b> NestedRuleParser<'a, 'b> { impl<'a, 'b> NestedRuleParser<'a, 'b> {
fn parse_nested_rules(&self, input: &mut Parser) -> CssRules { fn parse_nested_rules(&self, input: &mut Parser) -> Arc<RwLock<CssRules>> {
let mut iter = RuleListParser::new_for_nested_rule(input, self.clone()); let mut iter = RuleListParser::new_for_nested_rule(input, self.clone());
let mut rules = Vec::new(); let mut rules = Vec::new();
while let Some(result) = iter.next() { while let Some(result) = iter.next() {
@ -711,7 +704,7 @@ impl<'a, 'b> NestedRuleParser<'a, 'b> {
} }
} }
} }
rules.into() CssRules::new(rules)
} }
} }

2
components/style/stylist.rs
View file

@ -389,7 +389,7 @@ impl Stylist {
false false
} }
self.is_device_dirty |= stylesheets.iter().any(|stylesheet| { self.is_device_dirty |= stylesheets.iter().any(|stylesheet| {
mq_eval_changed(&stylesheet.rules.0.read(), &self.device, &device) mq_eval_changed(&stylesheet.rules.read().0, &self.device, &device)
}); });
self.device = device; self.device = device;

18
ports/geckolib/glue.rs
View file

@ -57,7 +57,7 @@ use style::restyle_hints::RestyleHint;
use style::selector_parser::PseudoElementCascadeType; use style::selector_parser::PseudoElementCascadeType;
use style::sequential; use style::sequential;
use style::string_cache::Atom; use style::string_cache::Atom;
use style::stylesheets::{CssRule, Origin, Stylesheet, StyleRule}; use style::stylesheets::{CssRule, CssRules, Origin, Stylesheet, StyleRule};
use style::thread_state; use style::thread_state;
use style::timer::Timer; use style::timer::Timer;
use style::traversal::{recalc_style_at, PerLevelTraversalData}; use style::traversal::{recalc_style_at, PerLevelTraversalData};
@ -293,12 +293,12 @@ pub extern "C" fn Servo_StyleSet_RemoveStyleSheet(raw_data: RawServoStyleSetBorr
#[no_mangle] #[no_mangle]
pub extern "C" fn Servo_StyleSheet_HasRules(raw_sheet: RawServoStyleSheetBorrowed) -> bool { pub extern "C" fn Servo_StyleSheet_HasRules(raw_sheet: RawServoStyleSheetBorrowed) -> bool {
!Stylesheet::as_arc(&raw_sheet).rules.0.read().is_empty() !Stylesheet::as_arc(&raw_sheet).rules.read().0.is_empty()
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn Servo_StyleSheet_GetRules(sheet: RawServoStyleSheetBorrowed) -> ServoCssRulesStrong { pub extern "C" fn Servo_StyleSheet_GetRules(sheet: RawServoStyleSheetBorrowed) -> ServoCssRulesStrong {
Stylesheet::as_arc(&sheet).rules.0.clone().into_strong() Stylesheet::as_arc(&sheet).rules.clone().into_strong()
} }
#[no_mangle] #[no_mangle]
@ -314,8 +314,8 @@ pub extern "C" fn Servo_StyleSheet_Release(sheet: RawServoStyleSheetBorrowed) ->
#[no_mangle] #[no_mangle]
pub extern "C" fn Servo_CssRules_ListTypes(rules: ServoCssRulesBorrowed, pub extern "C" fn Servo_CssRules_ListTypes(rules: ServoCssRulesBorrowed,
result: nsTArrayBorrowed_uintptr_t) -> () { result: nsTArrayBorrowed_uintptr_t) -> () {
let rules = RwLock::<Vec<CssRule>>::as_arc(&rules).read(); let rules = RwLock::<CssRules>::as_arc(&rules).read();
let iter = rules.iter().map(|rule| rule.rule_type() as usize); let iter = rules.0.iter().map(|rule| rule.rule_type() as usize);
let (size, upper) = iter.size_hint(); let (size, upper) = iter.size_hint();
debug_assert_eq!(size, upper.unwrap()); debug_assert_eq!(size, upper.unwrap());
unsafe { result.set_len(size as u32) }; unsafe { result.set_len(size as u32) };
@ -325,8 +325,8 @@ pub extern "C" fn Servo_CssRules_ListTypes(rules: ServoCssRulesBorrowed,
#[no_mangle] #[no_mangle]
pub extern "C" fn Servo_CssRules_GetStyleRuleAt(rules: ServoCssRulesBorrowed, index: u32) pub extern "C" fn Servo_CssRules_GetStyleRuleAt(rules: ServoCssRulesBorrowed, index: u32)
-> RawServoStyleRuleStrong { -> RawServoStyleRuleStrong {
let rules = RwLock::<Vec<CssRule>>::as_arc(&rules).read(); let rules = RwLock::<CssRules>::as_arc(&rules).read();
match rules[index as usize] { match rules.0[index as usize] {
CssRule::Style(ref rule) => rule.clone().into_strong(), CssRule::Style(ref rule) => rule.clone().into_strong(),
_ => { _ => {
unreachable!("GetStyleRuleAt should only be called on a style rule"); unreachable!("GetStyleRuleAt should only be called on a style rule");
@ -336,12 +336,12 @@ pub extern "C" fn Servo_CssRules_GetStyleRuleAt(rules: ServoCssRulesBorrowed, in
#[no_mangle] #[no_mangle]
pub extern "C" fn Servo_CssRules_AddRef(rules: ServoCssRulesBorrowed) -> () { pub extern "C" fn Servo_CssRules_AddRef(rules: ServoCssRulesBorrowed) -> () {
unsafe { RwLock::<Vec<CssRule>>::addref(rules) }; unsafe { RwLock::<CssRules>::addref(rules) };
} }
#[no_mangle] #[no_mangle]
pub extern "C" fn Servo_CssRules_Release(rules: ServoCssRulesBorrowed) -> () { pub extern "C" fn Servo_CssRules_Release(rules: ServoCssRulesBorrowed) -> () {
unsafe { RwLock::<Vec<CssRule>>::release(rules) }; unsafe { RwLock::<CssRules>::release(rules) };
} }
#[no_mangle] #[no_mangle]

2
tests/unit/style/media_queries.rs
View file

@ -31,7 +31,7 @@ fn test_media_rule<F>(css: &str, callback: F) where F: Fn(&MediaList, &str) {
css, url, Origin::Author, Default::default(), css, url, Origin::Author, Default::default(),
Box::new(CSSErrorReporterTest), ParserContextExtraData::default()); Box::new(CSSErrorReporterTest), ParserContextExtraData::default());
let mut rule_count = 0; let mut rule_count = 0;
media_queries(&stylesheet.rules.0.read(), &mut |mq| { media_queries(&stylesheet.rules.read().0, &mut |mq| {
rule_count += 1; rule_count += 1;
callback(mq, css); callback(mq, css);
}); });

6
tests/unit/style/stylesheets.rs
View file

@ -20,7 +20,7 @@ use style::properties::{PropertyDeclaration, PropertyDeclarationBlock, DeclaredV
use style::properties::Importance; use style::properties::Importance;
use style::properties::longhands::animation_play_state; use style::properties::longhands::animation_play_state;
use style::stylesheets::{Origin, Namespaces}; use style::stylesheets::{Origin, Namespaces};
use style::stylesheets::{Stylesheet, NamespaceRule, CssRule, StyleRule, KeyframesRule}; use style::stylesheets::{Stylesheet, NamespaceRule, CssRule, CssRules, StyleRule, KeyframesRule};
use style::values::specified::{LengthOrPercentageOrAuto, Percentage}; use style::values::specified::{LengthOrPercentageOrAuto, Percentage};
#[test] #[test]
@ -63,7 +63,7 @@ fn test_parse_stylesheet() {
base_url: url, base_url: url,
dirty_on_viewport_size_change: AtomicBool::new(false), dirty_on_viewport_size_change: AtomicBool::new(false),
disabled: AtomicBool::new(false), disabled: AtomicBool::new(false),
rules: vec![ rules: CssRules::new(vec![
CssRule::Namespace(Arc::new(RwLock::new(NamespaceRule { CssRule::Namespace(Arc::new(RwLock::new(NamespaceRule {
prefix: None, prefix: None,
url: NsAtom::from("http://www.w3.org/1999/xhtml") url: NsAtom::from("http://www.w3.org/1999/xhtml")
@ -263,7 +263,7 @@ fn test_parse_stylesheet() {
] ]
}))) })))
].into(), ]),
}; };
assert_eq!(format!("{:#?}", stylesheet), format!("{:#?}", expected)); assert_eq!(format!("{:#?}", stylesheet), format!("{:#?}", expected));