Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Propagate quirks mode all the way to ParserContext

Browse source 
The quirks mode is still not properly propagated in geckolib.
This commit is contained in:
Anthony Ramine 2017-04-23 11:07:48 +02:00
parent 10fb8e61c7
commit f68e2fded9
39 changed files with 225 additions and 100 deletions
Download patch file Download diff file Expand all files Collapse all files

5
components/layout_thread/lib.rs
View file

@ -1589,7 +1589,8 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
MediaList::empty(),
shared_lock.clone(),
None,
&NullReporter))
&NullReporter,
QuirksMode::NoQuirks))
}
let shared_lock = SharedRwLock::new();
@ -1602,7 +1603,7 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
for &(ref contents, ref url) in &opts::get().user_stylesheets {
user_or_user_agent_stylesheets.push(Stylesheet::from_bytes(
&contents, url.clone(), None, None, Origin::User, MediaList::empty(),
shared_lock.clone(), None, &RustLogReporter));
shared_lock.clone(), None, &RustLogReporter, QuirksMode::NoQuirks));
}
let quirks_mode_stylesheet = try!(parse_ua_stylesheet(&shared_lock, "quirks-mode.css"));

7
components/script/dom/css.rs
View file

@ -9,6 +9,7 @@ use dom::bindings::reflector::Reflector;
use dom::bindings::str::DOMString;
use dom::window::Window;
use dom_struct::dom_struct;
use style::context::QuirksMode;
use style::parser::{LengthParsingMode, ParserContext};
use style::stylesheets::CssRuleType;
use style::supports::{Declaration, parse_condition_or_declaration};
@ -31,7 +32,8 @@ impl CSS {
let decl = Declaration { prop: property.into(), val: value.into() };
let url = win.Document().url();
let context = ParserContext::new_for_cssom(&url, win.css_error_reporter(), Some(CssRuleType::Supports),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
decl.eval(&context)
}
@ -42,7 +44,8 @@ impl CSS {
if let Ok(cond) = cond {
let url = win.Document().url();
let context = ParserContext::new_for_cssom(&url, win.css_error_reporter(), Some(CssRuleType::Supports),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
cond.eval(&context)
} else {
false

5
components/script/dom/cssmediarule.rs
View file

@ -5,6 +5,7 @@
use cssparser::Parser;
use dom::bindings::codegen::Bindings::CSSMediaRuleBinding;
use dom::bindings::codegen::Bindings::CSSMediaRuleBinding::CSSMediaRuleMethods;
use dom::bindings::codegen::Bindings::WindowBinding::WindowBinding::WindowMethods;
use dom::bindings::js::{MutNullableJS, Root};
use dom::bindings::reflector::{DomObject, reflect_dom_object};
use dom::bindings::str::DOMString;
@ -72,8 +73,10 @@ impl CSSMediaRule {
let global = self.global();
let win = global.as_window();
let url = win.get_url();
let quirks_mode = win.Document().quirks_mode();
let context = ParserContext::new_for_cssom(&url, win.css_error_reporter(), Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
let new_medialist = parse_media_query_list(&context, &mut input);
let mut guard = self.cssconditionrule.shared_lock().write();

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

@ -256,9 +256,12 @@ impl CSSStyleDeclaration {
// Step 6
let window = self.owner.window();
let quirks_mode = window.Document().quirks_mode();
let result =
parse_one_declaration(id, &value, &self.owner.base_url(),
window.css_error_reporter(), LengthParsingMode::Default);
window.css_error_reporter(),
LengthParsingMode::Default,
quirks_mode);
// Step 7
let parsed = match result {
@ -434,11 +437,13 @@ impl CSSStyleDeclarationMethods for CSSStyleDeclaration {
return Err(Error::NoModificationAllowed);
}
let quirks_mode = window.Document().quirks_mode();
self.owner.mutate_associated_block(|mut pdb, mut _changed| {
// Step 3
*pdb = parse_style_attribute(&value,
&self.owner.base_url(),
window.css_error_reporter());
window.css_error_reporter(),
quirks_mode);
});
Ok(())

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

@ -61,8 +61,10 @@ impl CSSSupportsRule {
let global = self.global();
let win = global.as_window();
let url = win.Document().url();
let quirks_mode = win.Document().quirks_mode();
let context = ParserContext::new_for_cssom(&url, win.css_error_reporter(), Some(CssRuleType::Supports),
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
let enabled = cond.eval(&context);
let mut guard = self.cssconditionrule.shared_lock().write();
let rule = self.supportsrule.write_with(&mut guard);

3
components/script/dom/element.rs
View file

@ -2196,7 +2196,8 @@ impl VirtualMethods for Element {
Arc::new(doc.style_shared_lock().wrap(parse_style_attribute(
&attr.value(),
&doc.base_url(),
win.css_error_reporter())))
win.css_error_reporter(),
doc.quirks_mode())))
};
Some(block)

3
components/script/dom/htmllinkelement.rs
View file

@ -282,7 +282,8 @@ impl HTMLLinkElement {
let win = document.window();
let doc_url = document.url();
let context = CssParserContext::new_for_cssom(&doc_url, win.css_error_reporter(), Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
document.quirks_mode());
let media = parse_media_query_list(&context, &mut css_parser);
let im_attribute = element.get_attribute(&ns!(), &local_name!("integrity"));

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

@ -113,6 +113,7 @@ impl HTMLMetaElement {
// force all styles to be recomputed.
dirty_on_viewport_size_change: AtomicBool::new(false),
disabled: AtomicBool::new(false),
quirks_mode: document.quirks_mode(),
}));
let doc = document_from_node(self);
doc.invalidate_stylesheets();

6
components/script/dom/htmlstyleelement.rs
View file

@ -76,6 +76,7 @@ impl HTMLStyleElement {
assert!(node.is_in_doc());
let win = window_from_node(node);
let doc = document_from_node(self);
let mq_attribute = element.get_attribute(&ns!(), &local_name!("media"));
let mq_str = match mq_attribute {
@ -88,7 +89,8 @@ impl HTMLStyleElement {
let context = CssParserContext::new_for_cssom(&url,
win.css_error_reporter(),
Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
doc.quirks_mode());
let shared_lock = node.owner_doc().style_shared_lock().clone();
let mq = Arc::new(shared_lock.wrap(
parse_media_query_list(&context, &mut CssParser::new(&mq_str))));
@ -96,6 +98,7 @@ impl HTMLStyleElement {
let sheet = Stylesheet::from_str(&data, win.get_url(), Origin::Author, mq,
shared_lock, Some(&loader),
win.css_error_reporter(),
doc.quirks_mode(),
self.line_number);
let sheet = Arc::new(sheet);
@ -107,7 +110,6 @@ impl HTMLStyleElement {
win.layout_chan().send(Msg::AddStylesheet(sheet.clone())).unwrap();
*self.stylesheet.borrow_mut() = Some(sheet);
let doc = document_from_node(self);
doc.invalidate_stylesheets();
}

13
components/script/dom/medialist.rs
View file

@ -5,6 +5,7 @@
use cssparser::Parser;
use dom::bindings::codegen::Bindings::MediaListBinding;
use dom::bindings::codegen::Bindings::MediaListBinding::MediaListMethods;
use dom::bindings::codegen::Bindings::WindowBinding::WindowBinding::WindowMethods;
use dom::bindings::js::{JS, Root};
use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
use dom::bindings::str::DOMString;
@ -74,8 +75,10 @@ impl MediaListMethods for MediaList {
let global = self.global();
let win = global.as_window();
let url = win.get_url();
let quirks_mode = win.Document().quirks_mode();
let context = ParserContext::new_for_cssom(&url, win.css_error_reporter(), Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
*media_queries = parse_media_query_list(&context, &mut parser);
}
@ -108,8 +111,10 @@ impl MediaListMethods for MediaList {
let global = self.global();
let win = global.as_window();
let url = win.get_url();
let quirks_mode = win.Document().quirks_mode();
let context = ParserContext::new_for_cssom(&url, win.css_error_reporter(), Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
let m = MediaQuery::parse(&context, &mut parser);
// Step 2
if let Err(_) = m {
@ -134,8 +139,10 @@ impl MediaListMethods for MediaList {
let global = self.global();
let win = global.as_window();
let url = win.get_url();
let quirks_mode = win.Document().quirks_mode();
let context = ParserContext::new_for_cssom(&url, win.css_error_reporter(), Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
let m = MediaQuery::parse(&context, &mut parser);
// Step 2
if let Err(_) = m {

2
components/script/dom/mediaquerylist.rs
View file

@ -77,7 +77,7 @@ impl MediaQueryList {
if let Some(window_size) = self.document.window().window_size() {
let viewport_size = window_size.initial_viewport;
let device = Device::new(MediaType::Screen, viewport_size);
self.media_query_list.evaluate(&device)
self.media_query_list.evaluate(&device, self.document.quirks_mode())
} else {
false
}

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

@ -976,8 +976,10 @@ impl WindowMethods for Window {
fn MatchMedia(&self, query: DOMString) -> Root<MediaQueryList> {
let mut parser = Parser::new(&query);
let url = self.get_url();
let quirks_mode = self.Document().quirks_mode();
let context = CssParserContext::new_for_cssom(&url, self.css_error_reporter(), Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
let media_query_list = media_queries::parse_media_query_list(&context, &mut parser);
let document = self.Document();
let mql = MediaQueryList::new(&document, media_query_list);

3
components/script/stylesheet_loader.rs
View file

@ -144,7 +144,8 @@ impl FetchResponseListener for StylesheetContext {
media.take().unwrap(),
shared_lock,
Some(&loader),
win.css_error_reporter()));
win.css_error_reporter(),
document.quirks_mode()));
if link.is_alternate() {
sheet.set_disabled(true);

3
components/style/animation.rs
View file

@ -451,7 +451,8 @@ fn compute_style_for_animation_step(context: &SharedStyleContext,
/* cascade_info = */ None,
&*context.error_reporter,
font_metrics_provider,
CascadeFlags::empty());
CascadeFlags::empty(),
context.quirks_mode);
computed
}
}

5
components/style/encoding_support.rs
View file

@ -6,6 +6,7 @@
extern crate encoding;
use context::QuirksMode;
use cssparser::{stylesheet_encoding, EncodingSupport};
use error_reporting::ParseErrorReporter;
use media_queries::MediaList;
@ -56,7 +57,8 @@ impl Stylesheet {
media: MediaList,
shared_lock: SharedRwLock,
stylesheet_loader: Option<&StylesheetLoader>,
error_reporter: &ParseErrorReporter)
error_reporter: &ParseErrorReporter,
quirks_mode: QuirksMode)
-> Stylesheet {
let (string, _) = decode_stylesheet_bytes(
bytes, protocol_encoding_label, environment_encoding);
@ -67,6 +69,7 @@ impl Stylesheet {
shared_lock,
stylesheet_loader,
error_reporter,
quirks_mode,
0u64)
}

10
components/style/gecko/media_queries.rs
View file

@ -5,6 +5,7 @@
//! Gecko's media-query device and expression representation.
use app_units::Au;
use context::QuirksMode;
use cssparser::{CssStringWriter, Parser, Token};
use euclid::Size2D;
use font_metrics::get_metrics_provider_for_product;
@ -521,7 +522,7 @@ impl Expression {
}
/// Returns whether this media query evaluates to true for the given device.
pub fn matches(&self, device: &Device) -> bool {
pub fn matches(&self, device: &Device, quirks_mode: QuirksMode) -> bool {
let mut css_value = nsCSSValue::null();
unsafe {
(self.feature.mGetter.unwrap())(device.pres_context,
@ -534,12 +535,13 @@ impl Expression {
None => return false,
};
self.evaluate_against(device, &value)
self.evaluate_against(device, &value, quirks_mode)
}
fn evaluate_against(&self,
device: &Device,
actual_value: &MediaExpressionValue)
actual_value: &MediaExpressionValue,
quirks_mode: QuirksMode)
-> bool {
use self::MediaExpressionValue::*;
use std::cmp::Ordering;
@ -564,6 +566,8 @@ impl Expression {
style: default_values.clone(),
font_metrics_provider: &provider,
in_media_query: true,
// TODO: pass the correct value here.
quirks_mode: quirks_mode,
};
let required_value = match self.value {

4
components/style/gecko/wrapper.rs
View file

@ -16,7 +16,7 @@
use app_units::Au;
use atomic_refcell::AtomicRefCell;
use context::{SharedStyleContext, UpdateAnimationsTasks};
use context::{QuirksMode, SharedStyleContext, UpdateAnimationsTasks};
use data::ElementData;
use dom::{self, AnimationRules, DescendantsBit, LayoutIterator, NodeInfo, TElement, TNode, UnsafeNode};
use dom::{OpaqueNode, PresentationalHintsSynthetizer};
@ -324,7 +324,7 @@ impl<'le> GeckoElement<'le> {
/// Parse the style attribute of an element.
pub fn parse_style_attribute(value: &str,
url_data: &UrlExtraData) -> PropertyDeclarationBlock {
parse_style_attribute(value, url_data, &RustLogReporter)
parse_style_attribute(value, url_data, &RustLogReporter, QuirksMode::NoQuirks)
}
fn flags(&self) -> u32 {

3
components/style/keyframes.rs
View file

@ -131,7 +131,8 @@ impl Keyframe {
&parent_stylesheet.url_data,
&error_reporter,
Some(CssRuleType::Keyframe),
LengthParsingMode::Default);
LengthParsingMode::Default,
parent_stylesheet.quirks_mode);
let mut input = Parser::new(css);
let mut rule_parser = KeyframeListParser {

3
components/style/matching.rs
View file

@ -453,7 +453,8 @@ trait PrivateMatchMethods: TElement {
Some(&mut cascade_info),
&*shared_context.error_reporter,
font_metrics_provider,
cascade_flags));
cascade_flags,
shared_context.quirks_mode));
cascade_info.finish(&self.as_node());
values

5
components/style/media_queries.rs
View file

@ -7,6 +7,7 @@
//! [mq]: https://drafts.csswg.org/mediaqueries/
use Atom;
use context::QuirksMode;
use cssparser::{Delimiter, Parser, Token};
use parser::ParserContext;
use serialize_comma_separated_list;
@ -280,7 +281,7 @@ pub fn parse_media_query_list(context: &ParserContext, input: &mut Parser) -> Me
impl MediaList {
/// Evaluate a whole `MediaList` against `Device`.
pub fn evaluate(&self, device: &Device) -> bool {
pub fn evaluate(&self, device: &Device, quirks_mode: QuirksMode) -> bool {
// Check if it is an empty media query list or any queries match (OR condition)
// https://drafts.csswg.org/mediaqueries-4/#mq-list
self.media_queries.is_empty() || self.media_queries.iter().any(|mq| {
@ -290,7 +291,7 @@ impl MediaList {
let query_match =
media_match &&
mq.expressions.iter()
.all(|expression| expression.matches(&device));
.all(|expression| expression.matches(&device, quirks_mode));
// Apply the logical NOT qualifier to the result
match mq.qualifier {

17
components/style/parser.rs
View file

@ -6,6 +6,7 @@
#![deny(missing_docs)]
use context::QuirksMode;
use cssparser::{Parser, SourcePosition, UnicodeRange};
use error_reporting::ParseErrorReporter;
use style_traits::OneOrMoreCommaSeparated;
@ -44,6 +45,8 @@ pub struct ParserContext<'a> {
pub line_number_offset: u64,
/// The mode to use when parsing lengths.
pub length_parsing_mode: LengthParsingMode,
/// The quirks mode of this stylesheet.
pub quirks_mode: QuirksMode,
}
impl<'a> ParserContext<'a> {
@ -52,7 +55,8 @@ impl<'a> ParserContext<'a> {
url_data: &'a UrlExtraData,
error_reporter: &'a ParseErrorReporter,
rule_type: Option<CssRuleType>,
length_parsing_mode: LengthParsingMode)
length_parsing_mode: LengthParsingMode,
quirks_mode: QuirksMode)
-> ParserContext<'a> {
ParserContext {
stylesheet_origin: stylesheet_origin,
@ -61,6 +65,7 @@ impl<'a> ParserContext<'a> {
rule_type: rule_type,
line_number_offset: 0u64,
length_parsing_mode: length_parsing_mode,
quirks_mode: quirks_mode,
}
}
@ -68,9 +73,10 @@ impl<'a> ParserContext<'a> {
pub fn new_for_cssom(url_data: &'a UrlExtraData,
error_reporter: &'a ParseErrorReporter,
rule_type: Option<CssRuleType>,
length_parsing_mode: LengthParsingMode)
length_parsing_mode: LengthParsingMode,
quirks_mode: QuirksMode)
-> ParserContext<'a> {
Self::new(Origin::Author, url_data, error_reporter, rule_type, length_parsing_mode)
Self::new(Origin::Author, url_data, error_reporter, rule_type, length_parsing_mode, quirks_mode)
}
/// Create a parser context based on a previous context, but with a modified rule type.
@ -84,6 +90,7 @@ impl<'a> ParserContext<'a> {
rule_type: rule_type,
line_number_offset: context.line_number_offset,
length_parsing_mode: context.length_parsing_mode,
quirks_mode: context.quirks_mode,
}
}
@ -92,7 +99,8 @@ impl<'a> ParserContext<'a> {
url_data: &'a UrlExtraData,
error_reporter: &'a ParseErrorReporter,
line_number_offset: u64,
length_parsing_mode: LengthParsingMode)
length_parsing_mode: LengthParsingMode,
quirks_mode: QuirksMode)
-> ParserContext<'a> {
ParserContext {
stylesheet_origin: stylesheet_origin,
@ -101,6 +109,7 @@ impl<'a> ParserContext<'a> {
rule_type: None,
line_number_offset: line_number_offset,
length_parsing_mode: length_parsing_mode,
quirks_mode: quirks_mode,
}
}

13
components/style/properties/declaration_block.rs
View file

@ -6,6 +6,7 @@
#![deny(missing_docs)]
use context::QuirksMode;
use cssparser::{DeclarationListParser, parse_important};
use cssparser::{Parser, AtRuleParser, DeclarationParser, Delimiter};
use error_reporting::ParseErrorReporter;
@ -641,13 +642,15 @@ pub fn append_serialization<'a, W, I, N>(dest: &mut W,
/// shared between Servo and Gecko.
pub fn parse_style_attribute(input: &str,
url_data: &UrlExtraData,
error_reporter: &ParseErrorReporter)
error_reporter: &ParseErrorReporter,
quirks_mode: QuirksMode)
-> PropertyDeclarationBlock {
let context = ParserContext::new(Origin::Author,
url_data,
error_reporter,
Some(CssRuleType::Style),
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
parse_property_declaration_list(&context, &mut Parser::new(input))
}
@ -660,13 +663,15 @@ pub fn parse_one_declaration(id: PropertyId,
input: &str,
url_data: &UrlExtraData,
error_reporter: &ParseErrorReporter,
length_parsing_mode: LengthParsingMode)
length_parsing_mode: LengthParsingMode,
quirks_mode: QuirksMode)
-> Result<ParsedDeclaration, ()> {
let context = ParserContext::new(Origin::Author,
url_data,
error_reporter,
Some(CssRuleType::Style),
length_parsing_mode);
length_parsing_mode,
quirks_mode);
Parser::new(input).parse_entirely(|parser| {
ParsedDeclaration::parse(id, &context, parser)
.map_err(|_| ())

3
components/style/properties/helpers.mako.rs
View file

@ -277,6 +277,7 @@
% if not property.derived_from:
{
let custom_props = context.style().custom_properties();
let quirks_mode = context.quirks_mode;
::properties::substitute_variables_${property.ident}(
&declared_value, &custom_props,
|value| {
@ -349,7 +350,7 @@
}
}
}
}, error_reporter);
}, error_reporter, quirks_mode);
}
% if property.custom_cascade:

4
components/style/properties/helpers/animated_properties.mako.rs
View file

@ -515,6 +515,7 @@ impl AnimationValue {
% if prop.animatable:
LonghandId::${prop.camel_case} => {
let mut result = None;
let quirks_mode = context.quirks_mode;
::properties::substitute_variables_${prop.ident}_slow(
&variables.css,
variables.first_token_type,
@ -533,7 +534,8 @@ impl AnimationValue {
};
result = AnimationValue::from_declaration(&declaration, context, initial);
},
&reporter);
&reporter,
quirks_mode);
result
},
% else:

23
components/style/properties/properties.mako.rs
View file

@ -21,6 +21,7 @@ use cssparser::{Parser, TokenSerializationType};
use error_reporting::ParseErrorReporter;
#[cfg(feature = "servo")] use euclid::side_offsets::SideOffsets2D;
use computed_values;
use context::QuirksMode;
use font_metrics::FontMetricsProvider;
#[cfg(feature = "gecko")] use gecko_bindings::bindings;
#[cfg(feature = "gecko")] use gecko_bindings::structs::{self, nsCSSPropertyID};
@ -327,7 +328,8 @@ impl PropertyDeclarationIdSet {
% endif
custom_properties: &Option<Arc<::custom_properties::ComputedValuesMap>>,
f: F,
error_reporter: &ParseErrorReporter)
error_reporter: &ParseErrorReporter,
quirks_mode: QuirksMode)
% if property.boxed:
where F: FnOnce(&DeclaredValue<Box<longhands::${property.ident}::SpecifiedValue>>)
% else:
@ -341,7 +343,8 @@ impl PropertyDeclarationIdSet {
with_variables.from_shorthand,
custom_properties,
f,
error_reporter);
error_reporter,
quirks_mode);
} else {
f(value);
}
@ -356,7 +359,8 @@ impl PropertyDeclarationIdSet {
from_shorthand: Option<ShorthandId>,
custom_properties: &Option<Arc<::custom_properties::ComputedValuesMap>>,
f: F,
error_reporter: &ParseErrorReporter)
error_reporter: &ParseErrorReporter,
quirks_mode: QuirksMode)
% if property.boxed:
where F: FnOnce(&DeclaredValue<Box<longhands::${property.ident}::SpecifiedValue>>)
% else:
@ -374,7 +378,8 @@ impl PropertyDeclarationIdSet {
url_data,
error_reporter,
None,
LengthParsingMode::Default);
LengthParsingMode::Default,
quirks_mode);
Parser::new(&css).parse_entirely(|input| {
match from_shorthand {
None => {
@ -2114,7 +2119,8 @@ pub fn cascade(device: &Device,
cascade_info: Option<<&mut CascadeInfo>,
error_reporter: &ParseErrorReporter,
font_metrics_provider: &FontMetricsProvider,
flags: CascadeFlags)
flags: CascadeFlags,
quirks_mode: QuirksMode)
-> ComputedValues {
debug_assert_eq!(parent_style.is_some(), layout_parent_style.is_some());
let (is_root_element, inherited_style, layout_parent_style) = match parent_style {
@ -2159,7 +2165,8 @@ pub fn cascade(device: &Device,
cascade_info,
error_reporter,
font_metrics_provider,
flags)
flags,
quirks_mode)
}
/// NOTE: This function expects the declaration with more priority to appear
@ -2173,7 +2180,8 @@ pub fn apply_declarations<'a, F, I>(device: &Device,
mut cascade_info: Option<<&mut CascadeInfo>,
error_reporter: &ParseErrorReporter,
font_metrics_provider: &FontMetricsProvider,
flags: CascadeFlags)
flags: CascadeFlags,
quirks_mode: QuirksMode)
-> ComputedValues
where F: Fn() -> I,
I: Iterator<Item = &'a PropertyDeclaration>,
@ -2226,6 +2234,7 @@ pub fn apply_declarations<'a, F, I>(device: &Device,
style: starting_style,
font_metrics_provider: font_metrics_provider,
in_media_query: false,
quirks_mode: quirks_mode,
};
// Set computed values, overwriting earlier declarations for the same

8
components/style/servo/media_queries.rs
View file

@ -5,6 +5,7 @@
//! Servo's media-query device and expression representation.
use app_units::Au;
use context::QuirksMode;
use cssparser::Parser;
use euclid::{Size2D, TypedSize2D};
use font_metrics::ServoMetricsProvider;
@ -128,12 +129,12 @@ impl Expression {
/// Evaluate this expression and return whether it matches the current
/// device.
pub fn matches(&self, device: &Device) -> bool {
pub fn matches(&self, device: &Device, quirks_mode: QuirksMode) -> bool {
let viewport_size = device.au_viewport_size();
let value = viewport_size.width;
match self.0 {
ExpressionKind::Width(ref range) => {
match range.to_computed_range(device) {
match range.to_computed_range(device, quirks_mode) {
Range::Min(ref width) => { value >= *width },
Range::Max(ref width) => { value <= *width },
Range::Eq(ref width) => { value == *width },
@ -175,7 +176,7 @@ pub enum Range<T> {
}
impl Range<specified::Length> {
fn to_computed_range(&self, device: &Device) -> Range<Au> {
fn to_computed_range(&self, device: &Device, quirks_mode: QuirksMode) -> Range<Au> {
let default_values = device.default_computed_values();
// http://dev.w3.org/csswg/mediaqueries3/#units
// em units are relative to the initial font-size.
@ -192,6 +193,7 @@ impl Range<specified::Length> {
// ch units can exist in media queries.
font_metrics_provider: &ServoMetricsProvider,
in_media_query: true,
quirks_mode: quirks_mode,
};
match *self {

37
components/style/stylesheets.rs
View file

@ -7,6 +7,7 @@
#![deny(missing_docs)]
use {Atom, Prefix, Namespace};
use context::QuirksMode;
use counter_style::{CounterStyleRule, parse_counter_style_name, parse_counter_style_body};
use cssparser::{AtRuleParser, Parser, QualifiedRuleParser};
use cssparser::{AtRuleType, RuleListParser, parse_one_rule};
@ -263,6 +264,8 @@ pub struct Stylesheet {
pub dirty_on_viewport_size_change: AtomicBool,
/// Whether this stylesheet should be disabled.
pub disabled: AtomicBool,
/// The quirks mode of this stylesheet.
pub quirks_mode: QuirksMode,
}
@ -415,7 +418,8 @@ impl CssRule {
&parent_stylesheet.url_data,
&error_reporter,
None,
LengthParsingMode::Default);
LengthParsingMode::Default,
parent_stylesheet.quirks_mode);
let mut input = Parser::new(css);
// nested rules are in the body state
@ -663,7 +667,7 @@ impl Stylesheet {
let (rules, dirty_on_viewport_size_change) = Stylesheet::parse_rules(
css, url_data, existing.origin, &mut namespaces,
&existing.shared_lock, stylesheet_loader, error_reporter,
0u64);
existing.quirks_mode, 0u64);
*existing.namespaces.write() = namespaces;
existing.dirty_on_viewport_size_change
@ -681,6 +685,7 @@ impl Stylesheet {
shared_lock: &SharedRwLock,
stylesheet_loader: Option<&StylesheetLoader>,
error_reporter: &ParseErrorReporter,
quirks_mode: QuirksMode,
line_number_offset: u64)
-> (Vec<CssRule>, bool) {
let mut rules = Vec::new();
@ -691,7 +696,8 @@ impl Stylesheet {
shared_lock: shared_lock,
loader: stylesheet_loader,
context: ParserContext::new_with_line_number_offset(origin, url_data, error_reporter,
line_number_offset, LengthParsingMode::Default),
line_number_offset, LengthParsingMode::Default,
quirks_mode),
state: Cell::new(State::Start),
};
@ -726,11 +732,13 @@ impl Stylesheet {
shared_lock: SharedRwLock,
stylesheet_loader: Option<&StylesheetLoader>,
error_reporter: &ParseErrorReporter,
line_number_offset: u64) -> Stylesheet {
quirks_mode: QuirksMode,
line_number_offset: u64)
-> Stylesheet {
let mut namespaces = Namespaces::default();
let (rules, dirty_on_viewport_size_change) = Stylesheet::parse_rules(
css, &url_data, origin, &mut namespaces,
&shared_lock, stylesheet_loader, error_reporter, line_number_offset
&shared_lock, stylesheet_loader, error_reporter, quirks_mode, line_number_offset,
);
Stylesheet {
origin: origin,
@ -741,6 +749,7 @@ impl Stylesheet {
shared_lock: shared_lock,
dirty_on_viewport_size_change: AtomicBool::new(dirty_on_viewport_size_change),
disabled: AtomicBool::new(false),
quirks_mode: quirks_mode,
}
}
@ -769,7 +778,7 @@ impl Stylesheet {
///
/// Always true if no associated MediaList exists.
pub fn is_effective_for_device(&self, device: &Device, guard: &SharedRwLockReadGuard) -> bool {
self.media.read_with(guard).evaluate(device)
self.media.read_with(guard).evaluate(device, self.quirks_mode)
}
/// Return an iterator over the effective rules within the style-sheet, as
@ -781,7 +790,7 @@ impl Stylesheet {
#[inline]
pub fn effective_rules<F>(&self, device: &Device, guard: &SharedRwLockReadGuard, mut f: F)
where F: FnMut(&CssRule) {
effective_rules(&self.rules.read_with(guard).0, device, guard, &mut f);
effective_rules(&self.rules.read_with(guard).0, device, self.quirks_mode, guard, &mut f);
}
/// Returns whether the stylesheet has been explicitly disabled through the
@ -802,17 +811,22 @@ impl Stylesheet {
}
}
fn effective_rules<F>(rules: &[CssRule], device: &Device, guard: &SharedRwLockReadGuard, f: &mut F)
where F: FnMut(&CssRule) {
fn effective_rules<F>(rules: &[CssRule],
device: &Device,
quirks_mode: QuirksMode,
guard: &SharedRwLockReadGuard,
f: &mut F)
where F: FnMut(&CssRule)
{
for rule in rules {
f(rule);
rule.with_nested_rules_and_mq(guard, |rules, mq| {
if let Some(media_queries) = mq {
if !media_queries.evaluate(device) {
if !media_queries.evaluate(device, quirks_mode) {
return
}
}
effective_rules(rules, device, guard, f)
effective_rules(rules, device, quirks_mode, guard, f)
})
}
}
@ -973,6 +987,7 @@ impl<'a> AtRuleParser for TopLevelRuleParser<'a> {
namespaces: RwLock::new(Namespaces::default()),
dirty_on_viewport_size_change: AtomicBool::new(false),
disabled: AtomicBool::new(false),
quirks_mode: self.context.quirks_mode,
})
}
}, &mut |import_rule| {

23
components/style/stylist.rs
View file

@ -240,7 +240,7 @@ impl Stylist {
};
self.viewport_constraints =
ViewportConstraints::maybe_new(&self.device, &cascaded_rule);
ViewportConstraints::maybe_new(&self.device, &cascaded_rule, self.quirks_mode);
if let Some(ref constraints) = self.viewport_constraints {
Arc::get_mut(&mut self.device).unwrap()
@ -418,7 +418,8 @@ impl Stylist {
None,
&RustLogReporter,
font_metrics,
cascade_flags);
cascade_flags,
self.quirks_mode);
ComputedStyle::new(rule_node, Arc::new(computed))
}
@ -536,7 +537,8 @@ impl Stylist {
None,
&RustLogReporter,
font_metrics,
CascadeFlags::empty());
CascadeFlags::empty(),
self.quirks_mode);
Some(ComputedStyle::new(rule_node, Arc::new(computed)))
}
@ -569,22 +571,22 @@ impl Stylist {
};
self.viewport_constraints =
ViewportConstraints::maybe_new(&device, &cascaded_rule);
ViewportConstraints::maybe_new(&device, &cascaded_rule, self.quirks_mode);
if let Some(ref constraints) = self.viewport_constraints {
device.account_for_viewport_rule(constraints);
}
fn mq_eval_changed(guard: &SharedRwLockReadGuard, rules: &[CssRule],
before: &Device, after: &Device) -> bool {
before: &Device, after: &Device, quirks_mode: QuirksMode) -> bool {
for rule in rules {
let changed = rule.with_nested_rules_and_mq(guard, |rules, mq| {
if let Some(mq) = mq {
if mq.evaluate(before) != mq.evaluate(after) {
if mq.evaluate(before, quirks_mode) != mq.evaluate(after, quirks_mode) {
return true
}
}
mq_eval_changed(guard, rules, before, after)
mq_eval_changed(guard, rules, before, after, quirks_mode)
});
if changed {
return true
@ -594,11 +596,11 @@ impl Stylist {
}
self.is_device_dirty |= stylesheets.iter().any(|stylesheet| {
let mq = stylesheet.media.read_with(guard);
if mq.evaluate(&self.device) != mq.evaluate(&device) {
if mq.evaluate(&self.device, self.quirks_mode) != mq.evaluate(&device, self.quirks_mode) {
return true
}
mq_eval_changed(guard, &stylesheet.rules.read_with(guard).0, &self.device, &device)
mq_eval_changed(guard, &stylesheet.rules.read_with(guard).0, &self.device, &device, self.quirks_mode)
});
self.device = Arc::new(device);
@ -866,7 +868,8 @@ impl Stylist {
None,
&RustLogReporter,
&metrics,
CascadeFlags::empty()))
CascadeFlags::empty(),
self.quirks_mode))
}
}

4
components/style/values/computed/mod.rs
View file

@ -4,6 +4,7 @@
//! Computed values.
use context::QuirksMode;
use euclid::size::Size2D;
use font_metrics::FontMetricsProvider;
use media_queries::Device;
@ -63,6 +64,9 @@ pub struct Context<'a> {
/// Whether or not we are computing the media list in a media query
pub in_media_query: bool,
/// The quirks mode of this context.
pub quirks_mode: QuirksMode,
}
impl<'a> Context<'a> {

8
components/style/viewport.rs
View file

@ -10,6 +10,7 @@
#![deny(missing_docs)]
use app_units::Au;
use context::QuirksMode;
use cssparser::{AtRuleParser, DeclarationListParser, DeclarationParser, Parser, parse_important};
use cssparser::ToCss as ParserToCss;
use euclid::size::TypedSize2D;
@ -588,13 +589,15 @@ pub trait MaybeNew {
/// Create a ViewportConstraints from a viewport size and a `@viewport`
/// rule.
fn maybe_new(device: &Device,
rule: &ViewportRule)
rule: &ViewportRule,
quirks_mode: QuirksMode)
-> Option<ViewportConstraints>;
}
impl MaybeNew for ViewportConstraints {
fn maybe_new(device: &Device,
rule: &ViewportRule)
rule: &ViewportRule,
quirks_mode: QuirksMode)
-> Option<ViewportConstraints>
{
use std::cmp;
@ -684,6 +687,7 @@ impl MaybeNew for ViewportConstraints {
style: device.default_computed_values().clone(),
font_metrics_provider: &provider,
in_media_query: false,
quirks_mode: quirks_mode,
};
// DEVICE-ADAPT § 9.3 Resolving 'extend-to-zoom'

37
ports/geckolib/glue.rs
View file

@ -511,7 +511,7 @@ pub extern "C" fn Servo_StyleSheet_Empty(mode: SheetParsingMode) -> RawServoStyl
Arc::new(Stylesheet::from_str(
"", unsafe { dummy_url_data() }.clone(), origin,
Arc::new(shared_lock.wrap(MediaList::empty())),
shared_lock, None, &RustLogReporter, 0u64)
shared_lock, None, &RustLogReporter, QuirksMode::NoQuirks, Wh0u64)
).into_strong()
}
@ -554,7 +554,7 @@ pub extern "C" fn Servo_StyleSheet_FromUTF8Bytes(loader: *mut Loader,
Arc::new(Stylesheet::from_str(
input, url_data.clone(), origin, media,
shared_lock, loader, &RustLogReporter, 0u64)
shared_lock, loader, &RustLogReporter, QuirksMode::NoQuirks, 0u64)
).into_strong()
}
@ -1007,7 +1007,8 @@ pub extern "C" fn Servo_ParseProperty(property: nsCSSPropertyID, value: *const n
let url_data = unsafe { RefPtr::from_ptr_ref(&data) };
let reporter = RustLogReporter;
let context = ParserContext::new(Origin::Author, url_data, &reporter,
Some(CssRuleType::Style), LengthParsingMode::Default);
Some(CssRuleType::Style), LengthParsingMode::Default,
QuirksMode::NoQuirks);
match ParsedDeclaration::parse(id, &context, &mut Parser::new(value)) {
Ok(parsed) => {
@ -1030,7 +1031,8 @@ pub extern "C" fn Servo_ParseEasing(easing: *const nsAString,
let url_data = unsafe { RefPtr::from_ptr_ref(&data) };
let reporter = RustLogReporter;
let context = ParserContext::new(Origin::Author, url_data, &reporter,
Some(CssRuleType::Style), LengthParsingMode::Default);
Some(CssRuleType::Style), LengthParsingMode::Default,
QuirksMode::NoQuirks);
let easing = unsafe { (*easing).to_string() };
match transition_timing_function::single_value::parse(&context, &mut Parser::new(&easing)) {
Ok(parsed_easing) => {
@ -1171,7 +1173,7 @@ fn set_property(declarations: RawServoDeclarationBlockBorrowed, property_id: Pro
structs::LengthParsingMode::SVG => LengthParsingMode::SVG,
};
if let Ok(parsed) = parse_one_declaration(property_id, value, url_data, &RustLogReporter,
length_parsing_mode) {
length_parsing_mode, QuirksMode::NoQuirks) {
let importance = if is_important { Importance::Important } else { Importance::Normal };
write_locked_arc(declarations, |decls: &mut PropertyDeclarationBlock| {
parsed.expand_set_into(decls, importance)
@ -1238,7 +1240,7 @@ pub extern "C" fn Servo_MediaList_Matches(list: RawServoMediaListBorrowed,
-> bool {
let per_doc_data = PerDocumentStyleData::from_ffi(raw_data).borrow();
read_locked_arc(list, |list: &MediaList| {
list.evaluate(&per_doc_data.stylist.device)
list.evaluate(&per_doc_data.stylist.device, QuirksMode::NoQuirks)
})
}
@ -1265,7 +1267,8 @@ pub extern "C" fn Servo_MediaList_SetText(list: RawServoMediaListBorrowed, text:
let url_data = unsafe { dummy_url_data() };
let reporter = RustLogReporter;
let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
write_locked_arc(list, |list: &mut MediaList| {
*list = parse_media_query_list(&context, &mut parser);
})
@ -1296,7 +1299,8 @@ pub extern "C" fn Servo_MediaList_AppendMedium(list: RawServoMediaListBorrowed,
let url_data = unsafe { dummy_url_data() };
let reporter = RustLogReporter;
let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
write_locked_arc(list, |list: &mut MediaList| {
list.append_medium(&context, new_medium);
})
@ -1309,7 +1313,8 @@ pub extern "C" fn Servo_MediaList_DeleteMedium(list: RawServoMediaListBorrowed,
let url_data = unsafe { dummy_url_data() };
let reporter = RustLogReporter;
let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Media),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
write_locked_arc(list, |list: &mut MediaList| list.delete_medium(&context, old_medium))
}
@ -1662,7 +1667,8 @@ pub extern "C" fn Servo_DeclarationBlock_SetBackgroundImage(declarations:
let string = unsafe { (*value).to_string() };
let error_reporter = RustLogReporter;
let context = ParserContext::new(Origin::Author, url_data, &error_reporter,
Some(CssRuleType::Style), LengthParsingMode::Default);
Some(CssRuleType::Style), LengthParsingMode::Default,
QuirksMode::NoQuirks);
if let Ok(url) = SpecifiedUrl::parse_from_string(string.into(), &context) {
let decl = PropertyDeclaration::BackgroundImage(BackgroundImage(
vec![SingleBackgroundImage(
@ -1700,7 +1706,12 @@ pub extern "C" fn Servo_CSSSupports2(property: *const nsACString, value: *const
let value = unsafe { value.as_ref().unwrap().as_str_unchecked() };
let url_data = unsafe { dummy_url_data() };
parse_one_declaration(id, &value, url_data, &RustLogReporter, LengthParsingMode::Default).is_ok()
parse_one_declaration(id,
&value,
url_data,
&RustLogReporter,
LengthParsingMode::Default,
QuirksMode::NoQuirks).is_ok()
}
#[no_mangle]
@ -1712,7 +1723,8 @@ pub extern "C" fn Servo_CSSSupports(cond: *const nsACString) -> bool {
let url_data = unsafe { dummy_url_data() };
let reporter = RustLogReporter;
let context = ParserContext::new_for_cssom(url_data, &reporter, Some(CssRuleType::Style),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
cond.eval(&context)
} else {
false
@ -1944,6 +1956,7 @@ pub extern "C" fn Servo_GetComputedKeyframeValues(keyframes: RawGeckoKeyframeLis
style: (**style).clone(),
font_metrics_provider: &metrics,
in_media_query: false,
quirks_mode: QuirksMode::NoQuirks,
};
for (index, keyframe) in keyframes.iter().enumerate() {

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

@ -8,6 +8,7 @@ use servo_url::ServoUrl;
use std::borrow::ToOwned;
use std::sync::Arc;
use style::Atom;
use style::context::QuirksMode;
use style::error_reporting::ParseErrorReporter;
use style::media_queries::*;
use style::servo::media_queries::*;
@ -37,7 +38,7 @@ fn test_media_rule<F>(css: &str, callback: F)
let media_list = Arc::new(lock.wrap(MediaList::empty()));
let stylesheet = Stylesheet::from_str(
css, url, Origin::Author, media_list, lock,
None, &CSSErrorReporterTest, 0u64);
None, &CSSErrorReporterTest, QuirksMode::NoQuirks, 0u64);
let mut rule_count = 0;
let guard = stylesheet.shared_lock.read();
media_queries(&guard, &stylesheet.rules.read_with(&guard).0, &mut |mq| {
@ -66,7 +67,7 @@ fn media_query_test(device: &Device, css: &str, expected_rule_count: usize) {
let media_list = Arc::new(lock.wrap(MediaList::empty()));
let ss = Stylesheet::from_str(
css, url, Origin::Author, media_list, lock,
None, &CSSErrorReporterTest, 0u64);
None, &CSSErrorReporterTest, QuirksMode::NoQuirks, 0u64);
let mut rule_count = 0;
ss.effective_style_rules(device, &ss.shared_lock.read(), |_| rule_count += 1);
assert!(rule_count == expected_rule_count, css.to_owned());

2
tests/unit/style/parsing/image.rs
View file

@ -5,6 +5,7 @@
use euclid::size::TypedSize2D;
use parsing::parse;
use std::f32::consts::PI;
use style::context::QuirksMode;
use style::font_metrics::ServoMetricsProvider;
use style::media_queries::{Device, MediaType};
use style::properties::ComputedValues;
@ -51,6 +52,7 @@ fn test_linear_gradient() {
style: initial_style.clone(),
font_metrics_provider: &ServoMetricsProvider,
in_media_query: false,
quirks_mode: QuirksMode::NoQuirks,
};
assert_eq!(specified::AngleOrCorner::None.to_computed_value(&specified_context),
computed::AngleOrCorner::Angle(Angle::from_radians(PI)));

4
tests/unit/style/parsing/length.rs
View file

@ -5,6 +5,7 @@
use cssparser::Parser;
use media_queries::CSSErrorReporterTest;
use parsing::parse;
use style::context::QuirksMode;
use style::parser::{LengthParsingMode, Parse, ParserContext};
use style::stylesheets::{CssRuleType, Origin};
use style::values::specified::length::{AbsoluteLength, Length, NoCalcLength};
@ -38,7 +39,8 @@ fn test_length_parsing_modes() {
let url = ::servo_url::ServoUrl::parse("http://localhost").unwrap();
let reporter = CSSErrorReporterTest;
let context = ParserContext::new(Origin::Author, &url, &reporter,
Some(CssRuleType::Style), LengthParsingMode::SVG);
Some(CssRuleType::Style), LengthParsingMode::SVG,
QuirksMode::NoQuirks);
let mut parser = Parser::new("1");
let result = Length::parse(&context, &mut parser);
assert!(result.is_ok());

4
tests/unit/style/parsing/mod.rs
View file

@ -6,6 +6,7 @@
use cssparser::Parser;
use media_queries::CSSErrorReporterTest;
use style::context::QuirksMode;
use style::parser::{LengthParsingMode, ParserContext};
use style::stylesheets::{CssRuleType, Origin};
@ -13,7 +14,8 @@ fn parse<T, F: Fn(&ParserContext, &mut Parser) -> Result<T, ()>>(f: F, s: &str)
let url = ::servo_url::ServoUrl::parse("http://localhost").unwrap();
let reporter = CSSErrorReporterTest;
let context = ParserContext::new(Origin::Author, &url, &reporter, Some(CssRuleType::Style),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
let mut parser = Parser::new(s);
f(&context, &mut parser)
}

4
tests/unit/style/properties/mod.rs
View file

@ -4,6 +4,7 @@
use cssparser::Parser;
use media_queries::CSSErrorReporterTest;
use style::context::QuirksMode;
use style::parser::{LengthParsingMode, ParserContext};
use style::stylesheets::{CssRuleType, Origin};
@ -11,7 +12,8 @@ fn parse<T, F: Fn(&ParserContext, &mut Parser) -> Result<T, ()>>(f: F, s: &str)
let url = ::servo_url::ServoUrl::parse("http://localhost").unwrap();
let reporter = CSSErrorReporterTest;
let context = ParserContext::new(Origin::Author, &url, &reporter, Some(CssRuleType::Style),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
let mut parser = Parser::new(s);
f(&context, &mut parser)
}

2
tests/unit/style/rule_tree/bench.rs
View file

@ -6,6 +6,7 @@ use cssparser::{Parser, SourcePosition};
use rayon;
use servo_url::ServoUrl;
use std::sync::Arc;
use style::context::QuirksMode;
use style::error_reporting::ParseErrorReporter;
use style::media_queries::MediaList;
use style::properties::{longhands, Importance, PropertyDeclaration, PropertyDeclarationBlock};
@ -58,6 +59,7 @@ fn parse_rules(css: &str) -> Vec<(StyleSource, CascadeLevel)> {
lock,
None,
&ErrorringErrorReporter,
QuirksMode::NoQuirks,
0u64);
let guard = s.shared_lock.read();
let rules = s.rules.read_with(&guard);

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

@ -13,6 +13,7 @@ use std::borrow::ToOwned;
use std::sync::Arc;
use std::sync::Mutex;
use std::sync::atomic::AtomicBool;
use style::context::QuirksMode;
use style::error_reporting::ParseErrorReporter;
use style::keyframes::{Keyframe, KeyframeSelector, KeyframePercentage};
use style::media_queries::MediaList;
@ -66,7 +67,7 @@ fn test_parse_stylesheet() {
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
let stylesheet = Stylesheet::from_str(css, url.clone(), Origin::UserAgent, media, lock,
None, &CSSErrorReporterTest, 0u64);
None, &CSSErrorReporterTest, QuirksMode::NoQuirks, 0u64);
let mut namespaces = Namespaces::default();
namespaces.default = Some(ns!(html));
let expected = Stylesheet {
@ -77,6 +78,7 @@ fn test_parse_stylesheet() {
url_data: url,
dirty_on_viewport_size_change: AtomicBool::new(false),
disabled: AtomicBool::new(false),
quirks_mode: QuirksMode::NoQuirks,
rules: CssRules::new(vec![
CssRule::Namespace(Arc::new(stylesheet.shared_lock.wrap(NamespaceRule {
prefix: None,
@ -316,7 +318,7 @@ fn test_report_error_stylesheet() {
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
Stylesheet::from_str(css, url.clone(), Origin::UserAgent, media, lock,
None, &error_reporter, 5u64);
None, &error_reporter, QuirksMode::NoQuirks, 5u64);
let mut errors = errors.lock().unwrap();

19
tests/unit/style/viewport.rs
View file

@ -8,6 +8,7 @@ use media_queries::CSSErrorReporterTest;
use servo_config::prefs::{PREFS, PrefValue};
use servo_url::ServoUrl;
use std::sync::Arc;
use style::context::QuirksMode;
use style::media_queries::{Device, MediaList, MediaType};
use style::parser::{LengthParsingMode, Parse, ParserContext};
use style::shared_lock::SharedRwLock;
@ -32,6 +33,7 @@ macro_rules! stylesheet {
$shared_lock,
None,
&$error_reporter,
QuirksMode::NoQuirks,
0u64
))
}
@ -293,7 +295,8 @@ fn constrain_viewport() {
let url = ServoUrl::parse("http://localhost").unwrap();
let reporter = CSSErrorReporterTest;
let context = ParserContext::new(Origin::Author, &url, &reporter, Some(CssRuleType::Viewport),
LengthParsingMode::Default);
LengthParsingMode::Default,
QuirksMode::NoQuirks);
macro_rules! from_css {
($css:expr) => {
@ -303,9 +306,9 @@ fn constrain_viewport() {
let initial_viewport = TypedSize2D::new(800., 600.);
let device = Device::new(MediaType::Screen, initial_viewport);
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("")), None);
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(""), QuirksMode::NoQuirks), None);
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("width: 320px auto")),
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("width: 320px auto"), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
@ -317,7 +320,7 @@ fn constrain_viewport() {
orientation: Orientation::Auto
}));
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("width: 320px auto")),
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("width: 320px auto"), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
@ -329,10 +332,12 @@ fn constrain_viewport() {
orientation: Orientation::Auto
}));
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("width: 800px; height: 600px;\
assert_eq!(ViewportConstraints::maybe_new(&device,
from_css!("width: 800px; height: 600px;\
zoom: 1;\
user-zoom: zoom;\
orientation: auto;")),
orientation: auto;"),
QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
@ -346,7 +351,7 @@ fn constrain_viewport() {
let initial_viewport = TypedSize2D::new(200., 150.);
let device = Device::new(MediaType::Screen, initial_viewport);
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("width: 320px auto")),
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!("width: 320px auto"), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: TypedSize2D::new(320., 240.),