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

Remove usage of the deprecated .as_slice() in libstyle.

Browse source
This commit is contained in:
Simon Sapin 2015-02-13 08:30:22 +01:00
parent 1ceadf3813
commit 2ddb13db4b
6 changed files with 60 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

6
components/style/font_face.rs
View file

@ -20,11 +20,11 @@ pub fn iter_font_face_rules_inner<F>(rules: &[CSSRule], device: &Device,
CSSRule::Charset(..) |
CSSRule::Namespace(..) => {},
CSSRule::Media(ref rule) => if rule.media_queries.evaluate(device) {
iter_font_face_rules_inner(rule.rules.as_slice(), device, callback)
iter_font_face_rules_inner(&rule.rules, device, callback)
},
CSSRule::FontFace(ref rule) => {
for source in rule.sources.iter() {
callback(rule.family.as_slice(), source)
callback(&rule.family, source)
}
},
}
@ -130,7 +130,7 @@ fn parse_one_src(context: &ParserContext, input: &mut Parser) -> Result<Source,
let url = match input.next() {
// Parsing url()
Ok(Token::Url(url)) => {
UrlParser::new().base_url(context.base_url).parse(url.as_slice()).unwrap_or_else(
UrlParser::new().base_url(context.base_url).parse(&url).unwrap_or_else(
|_error| Url::parse("about:invalid").unwrap())
},
// Parsing local() with early return

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

@ -487,10 +487,10 @@ pub mod longhands {
Ok(SpecifiedValue::Percentage(value.unit_value))
}
Token::Dimension(ref value, ref unit) if value.value >= 0. => {
specified::Length::parse_dimension(value.value, unit.as_slice())
specified::Length::parse_dimension(value.value, unit)
.map(SpecifiedValue::Length)
}
Token::Ident(ref value) if value.as_slice().eq_ignore_ascii_case("normal") => {
Token::Ident(ref value) if value.eq_ignore_ascii_case("normal") => {
Ok(SpecifiedValue::Normal)
}
_ => Err(()),
@ -781,7 +781,7 @@ pub mod longhands {
if input.try(|input| input.expect_ident_matching("none")).is_ok() {
Ok(SpecifiedValue::None)
} else {
Ok(SpecifiedValue::Url(context.parse_url(try!(input.expect_url()).as_slice())))
Ok(SpecifiedValue::Url(context.parse_url(&*try!(input.expect_url()))))
}
}
#[inline]
@ -988,7 +988,7 @@ pub mod longhands {
impl FontFamily {
pub fn name(&self) -> &str {
match *self {
FontFamily::FamilyName(ref name) => name.as_slice(),
FontFamily::FamilyName(ref name) => name,
}
}
}
@ -1040,7 +1040,7 @@ pub mod longhands {
let mut value = first_ident.into_owned();
while let Ok(ident) = input.try(|input| input.expect_ident()) {
value.push_str(" ");
value.push_str(ident.as_slice());
value.push_str(&ident);
}
Ok(FontFamily::FamilyName(value))
}
@ -1555,7 +1555,7 @@ pub mod longhands {
if ident.eq_ignore_ascii_case("auto") {
Ok(SpecifiedValue::AutoCursor)
} else {
util_cursor::Cursor::from_css_keyword(ident.as_slice())
util_cursor::Cursor::from_css_keyword(&ident)
.map(SpecifiedValue::SpecifiedCursor)
}
}
@ -2600,9 +2600,9 @@ pub fn parse_property_declaration_list(context: &ParserContext, input: &mut Pars
match declaration {
Ok((results, important)) => {
if important {
important_declarations.push_all(results.as_slice());
important_declarations.push_all(&results);
} else {
normal_declarations.push_all(results.as_slice());
normal_declarations.push_all(&results);
}
}
Err(range) => {
@ -2727,11 +2727,12 @@ impl PropertyDeclaration {
}
pub fn matches(&self, name: &str) -> bool {
let name_lower = name.as_slice().to_ascii_lowercase();
match (self, name_lower.as_slice()) {
match *self {
% for property in LONGHANDS:
% if property.derived_from is None:
(&PropertyDeclaration::${property.camel_case}(..), "${property.name}") => true,
PropertyDeclaration::${property.camel_case}(..) => {
name.eq_ignore_ascii_case("${property.name}")
}
% endif
% endfor
_ => false,

30
components/style/selector_matching.rs
View file

@ -126,7 +126,7 @@ impl SelectorMap {
SelectorMap::get_matching_rules(node,
parent_bf,
self.universal_rules.as_slice(),
&self.universal_rules,
matching_rules_list,
shareable);
@ -151,7 +151,7 @@ impl SelectorMap {
Some(rules) => {
SelectorMap::get_matching_rules(node,
parent_bf,
rules.as_slice(),
rules,
matching_rules,
shareable)
}
@ -292,8 +292,8 @@ impl Stylist {
// (Does it make a difference?)
for &filename in ["user-agent.css", "servo.css", "presentational-hints.css"].iter() {
let ua_stylesheet = Stylesheet::from_bytes(
read_resource_file(&[filename]).unwrap().as_slice(),
Url::parse(format!("chrome:///{:?}", filename).as_slice()).unwrap(),
&read_resource_file(&[filename]).unwrap(),
Url::parse(&format!("chrome:///{:?}", filename)).unwrap(),
None,
None,
Origin::UserAgent);
@ -384,7 +384,7 @@ impl Stylist {
pub fn add_quirks_mode_stylesheet(&mut self) {
self.add_stylesheet(Stylesheet::from_bytes(
read_resource_file(&["quirks-mode.css"]).unwrap().as_slice(),
&read_resource_file(&["quirks-mode.css"]).unwrap(),
Url::parse("chrome:///quirks-mode.css").unwrap(),
None,
None,
@ -862,10 +862,10 @@ pub fn matches_simple_selector<'a,E,N>(selector: &SimpleSelector,
element.match_attr(attr, |_| true)
}
SimpleSelector::AttrEqual(ref attr, ref value, case_sensitivity) => {
if value.as_slice() != "DIR" &&
if *value != "DIR" &&
common_style_affecting_attributes().iter().all(|common_attr_info| {
!(common_attr_info.atom == attr.name && match common_attr_info.mode {
CommonStyleAffectingAttributeMode::IsEqual(target_value, _) => target_value == value.as_slice(),
CommonStyleAffectingAttributeMode::IsEqual(target_value, _) => *value == target_value,
CommonStyleAffectingAttributeMode::IsPresent(_) => false,
})
}) {
@ -875,40 +875,40 @@ pub fn matches_simple_selector<'a,E,N>(selector: &SimpleSelector,
}
element.match_attr(attr, |attr_value| {
match case_sensitivity {
CaseSensitivity::CaseSensitive => attr_value == value.as_slice(),
CaseSensitivity::CaseInsensitive => attr_value.eq_ignore_ascii_case(value.as_slice()),
CaseSensitivity::CaseSensitive => attr_value == *value,
CaseSensitivity::CaseInsensitive => attr_value.eq_ignore_ascii_case(value),
}
})
}
SimpleSelector::AttrIncludes(ref attr, ref value) => {
*shareable = false;
element.match_attr(attr, |attr_value| {
attr_value.split(SELECTOR_WHITESPACE).any(|v| v == value.as_slice())
attr_value.split(SELECTOR_WHITESPACE).any(|v| v == *value)
})
}
SimpleSelector::AttrDashMatch(ref attr, ref value, ref dashing_value) => {
*shareable = false;
element.match_attr(attr, |attr_value| {
attr_value == value.as_slice() ||
attr_value.starts_with(dashing_value.as_slice())
attr_value == *value ||
attr_value.starts_with(dashing_value)
})
}
SimpleSelector::AttrPrefixMatch(ref attr, ref value) => {
*shareable = false;
element.match_attr(attr, |attr_value| {
attr_value.starts_with(value.as_slice())
attr_value.starts_with(value)
})
}
SimpleSelector::AttrSubstringMatch(ref attr, ref value) => {
*shareable = false;
element.match_attr(attr, |attr_value| {
attr_value.contains(value.as_slice())
attr_value.contains(value)
})
}
SimpleSelector::AttrSuffixMatch(ref attr, ref value) => {
*shareable = false;
element.match_attr(attr, |attr_value| {
attr_value.ends_with(value.as_slice())
attr_value.ends_with(value)
})
}

27
components/style/selectors.rs
View file

@ -125,13 +125,13 @@ fn compute_specificity(mut selector: &CompoundSelector,
};
if pseudo_element.is_some() { specificity.element_selectors += 1 }
simple_selectors_specificity(selector.simple_selectors.as_slice(), &mut specificity);
simple_selectors_specificity(&selector.simple_selectors, &mut specificity);
loop {
match selector.next {
None => break,
Some((ref next_selector, _)) => {
selector = &**next_selector;
simple_selectors_specificity(selector.simple_selectors.as_slice(), &mut specificity)
simple_selectors_specificity(&selector.simple_selectors, &mut specificity)
}
}
}
@ -169,7 +169,7 @@ fn compute_specificity(mut selector: &CompoundSelector,
specificity.class_like_selectors += 1,
&SimpleSelector::Namespace(..) => (),
&SimpleSelector::Negation(ref negated) =>
simple_selectors_specificity(negated.as_slice(), specificity),
simple_selectors_specificity(negated, specificity),
}
}
}
@ -270,8 +270,8 @@ fn parse_type_selector(context: &ParserContext, input: &mut Parser)
match local_name {
Some(name) => {
simple_selectors.push(SimpleSelector::LocalName(LocalName {
name: Atom::from_slice(name.as_slice()),
lower_name: Atom::from_slice(name.into_owned().into_ascii_lowercase().as_slice())
name: Atom::from_slice(&name),
lower_name: Atom::from_slice(&name.into_owned().into_ascii_lowercase())
}))
}
None => (),
@ -322,7 +322,7 @@ fn parse_qualified_name<'i, 't>
let position = input.position();
match input.next_including_whitespace() {
Ok(Token::Delim('|')) => {
let result = context.namespaces.prefix_map.get(value.as_slice());
let result = context.namespaces.prefix_map.get(&*value);
let namespace = try!(result.ok_or(()));
explicit_namespace(input, NamespaceConstraint::Specific(namespace.clone()))
},
@ -366,8 +366,8 @@ fn parse_attribute_selector(context: &ParserContext, input: &mut Parser)
Some((_, None)) => unreachable!(),
Some((namespace, Some(local_name))) => AttrSelector {
namespace: namespace,
lower_name: Atom::from_slice(local_name.as_slice().to_ascii_lowercase().as_slice()),
name: Atom::from_slice(local_name.as_slice()),
lower_name: Atom::from_slice(&local_name.to_ascii_lowercase()),
name: Atom::from_slice(&local_name),
},
};
@ -526,13 +526,13 @@ fn parse_one_simple_selector(context: &ParserContext,
let start_position = input.position();
match input.next_including_whitespace() {
Ok(Token::IDHash(id)) => {
let id = SimpleSelector::ID(Atom::from_slice(id.as_slice()));
let id = SimpleSelector::ID(Atom::from_slice(&id));
Ok(Some(SimpleSelectorParseResult::SimpleSelector(id)))
}
Ok(Token::Delim('.')) => {
match input.next_including_whitespace() {
Ok(Token::Ident(class)) => {
let class = SimpleSelector::Class(Atom::from_slice(class.as_slice()));
let class = SimpleSelector::Class(Atom::from_slice(&class));
Ok(Some(SimpleSelectorParseResult::SimpleSelector(class)))
}
_ => Err(()),
@ -547,7 +547,7 @@ fn parse_one_simple_selector(context: &ParserContext,
Ok(Token::Colon) => {
match input.next_including_whitespace() {
Ok(Token::Ident(name)) => {
match parse_simple_pseudo_class(context, name.as_slice()) {
match parse_simple_pseudo_class(context, &name) {
Err(()) => {
let pseudo_element = match_ignore_ascii_case! { name,
// Supported CSS 2.1 pseudo-elements only.
@ -564,16 +564,15 @@ fn parse_one_simple_selector(context: &ParserContext,
}
}
Ok(Token::Function(name)) => {
let name = name.as_slice();
let pseudo = try!(input.parse_nested_block(|input| {
parse_functional_pseudo_class(context, input, name, inside_negation)
parse_functional_pseudo_class(context, input, &name, inside_negation)
}));
Ok(Some(SimpleSelectorParseResult::SimpleSelector(pseudo)))
}
Ok(Token::Colon) => {
match input.next() {
Ok(Token::Ident(name)) => {
let pseudo = try!(parse_pseudo_element(name.as_slice()));
let pseudo = try!(parse_pseudo_element(&name));
Ok(Some(SimpleSelectorParseResult::PseudoElement(pseudo)))
}
_ => Err(())

18
components/style/stylesheets.rs
View file

@ -63,12 +63,12 @@ impl Stylesheet {
pub fn from_bytes_iter<I: Iterator<Item=Vec<u8>>>(
input: I, base_url: Url, protocol_encoding_label: Option<&str>,
environment_encoding: Option<EncodingRef>, origin: Origin) -> Stylesheet {
let mut bytes = vec!();
let mut bytes = vec![];
// TODO: incremental decoding and tokenization/parsing
for chunk in input {
bytes.push_all(chunk.as_slice())
bytes.push_all(&chunk)
}
Stylesheet::from_bytes(bytes.as_slice(), base_url, protocol_encoding_label,
Stylesheet::from_bytes(&bytes, base_url, protocol_encoding_label,
environment_encoding, origin)
}
@ -80,8 +80,8 @@ impl Stylesheet {
-> Stylesheet {
// TODO: bytes.as_slice could be bytes.container_as_bytes()
let (string, _) = decode_stylesheet_bytes(
bytes.as_slice(), protocol_encoding_label, environment_encoding);
Stylesheet::from_str(string.as_slice(), base_url, origin)
bytes, protocol_encoding_label, environment_encoding);
Stylesheet::from_str(&string, base_url, origin)
}
pub fn from_str<'i>(css: &'i str, base_url: Url, origin: Origin) -> Stylesheet {
@ -188,7 +188,7 @@ impl<'a> AtRuleParser for TopLevelRuleParser<'a> {
self.state.set(State::Namespaces);
let prefix = input.try(|input| input.expect_ident()).ok().map(|p| p.into_owned());
let url = Namespace(Atom::from_slice(try!(input.expect_url_or_string()).as_slice()));
let url = Namespace(Atom::from_slice(&*try!(input.expect_url_or_string())));
return Ok(AtRuleType::WithoutBlock(CSSRule::Namespace(prefix, url)))
} else {
return Err(()) // "@namespace must be before any rule but @charset and @import"
@ -288,7 +288,7 @@ pub fn iter_style_rules<'a, F>(rules: &[CSSRule], device: &media_queries::Device
match *rule {
CSSRule::Style(ref rule) => callback(rule),
CSSRule::Media(ref rule) => if rule.media_queries.evaluate(device) {
iter_style_rules(rule.rules.as_slice(), device, callback)
iter_style_rules(&rule.rules, device, callback)
},
CSSRule::FontFace(..) |
CSSRule::Charset(..) |
@ -312,14 +312,14 @@ pub fn iter_stylesheet_media_rules<F>(stylesheet: &Stylesheet, mut callback: F)
#[inline]
pub fn iter_stylesheet_style_rules<F>(stylesheet: &Stylesheet, device: &media_queries::Device,
mut callback: F) where F: FnMut(&StyleRule) {
iter_style_rules(stylesheet.rules.as_slice(), device, &mut callback)
iter_style_rules(&stylesheet.rules, device, &mut callback)
}
#[inline]
pub fn iter_font_face_rules<F>(stylesheet: &Stylesheet, device: &Device,
callback: &F) where F: Fn(&str, &Source) {
iter_font_face_rules_inner(stylesheet.rules.as_slice(), device, callback)
iter_font_face_rules_inner(&stylesheet.rules, device, callback)
}

16
components/style/values.rs
View file

@ -89,7 +89,7 @@ pub mod specified {
impl ToCss for CSSColor {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
match self.authored {
Some(ref s) => dest.write_str(s.as_slice()),
Some(ref s) => dest.write_str(s),
None => self.parsed.to_css(dest),
}
}
@ -107,7 +107,7 @@ pub mod specified {
impl ToCss for CSSRGBA {
fn to_css<W>(&self, dest: &mut W) -> text_writer::Result where W: TextWriter {
match self.authored {
Some(ref s) => dest.write_str(s.as_slice()),
Some(ref s) => dest.write_str(s),
None => self.parsed.to_css(dest),
}
}
@ -171,7 +171,7 @@ pub mod specified {
fn parse_internal(input: &mut Parser, negative_ok: bool) -> Result<Length, ()> {
match try!(input.next()) {
Token::Dimension(ref value, ref unit) if negative_ok || value.value >= 0. => {
Length::parse_dimension(value.value, unit.as_slice())
Length::parse_dimension(value.value, unit)
}
Token::Number(ref value) if value.value == 0. => Ok(Length::Au(Au(0))),
_ => Err(())
@ -229,7 +229,7 @@ pub mod specified {
-> Result<LengthOrPercentage, ()> {
match try!(input.next()) {
Token::Dimension(ref value, ref unit) if negative_ok || value.value >= 0. => {
Length::parse_dimension(value.value, unit.as_slice())
Length::parse_dimension(value.value, unit)
.map(LengthOrPercentage::Length)
}
Token::Percentage(ref value) if negative_ok || value.unit_value >= 0. => {
@ -278,7 +278,7 @@ pub mod specified {
-> Result<LengthOrPercentageOrAuto, ()> {
match try!(input.next()) {
Token::Dimension(ref value, ref unit) if negative_ok || value.value >= 0. => {
Length::parse_dimension(value.value, unit.as_slice())
Length::parse_dimension(value.value, unit)
.map(LengthOrPercentageOrAuto::Length)
}
Token::Percentage(ref value) if negative_ok || value.unit_value >= 0. => {
@ -329,7 +329,7 @@ pub mod specified {
-> Result<LengthOrPercentageOrNone, ()> {
match try!(input.next()) {
Token::Dimension(ref value, ref unit) if negative_ok || value.value >= 0. => {
Length::parse_dimension(value.value, unit.as_slice())
Length::parse_dimension(value.value, unit)
.map(LengthOrPercentageOrNone::Length)
}
Token::Percentage(ref value) if negative_ok || value.unit_value >= 0. => {
@ -370,7 +370,7 @@ pub mod specified {
pub fn parse(input: &mut Parser) -> Result<PositionComponent, ()> {
match try!(input.next()) {
Token::Dimension(ref value, ref unit) => {
Length::parse_dimension(value.value, unit.as_slice())
Length::parse_dimension(value.value, unit)
.map(PositionComponent::Length)
}
Token::Percentage(ref value) => {
@ -479,7 +479,7 @@ pub mod specified {
pub fn parse(context: &ParserContext, input: &mut Parser) -> Result<Image, ()> {
match try!(input.next()) {
Token::Url(url) => {
Ok(Image::Url(context.parse_url(url.as_slice())))
Ok(Image::Url(context.parse_url(&url)))
}
Token::Function(name) => {
match_ignore_ascii_case! { name,