~[] to Vec in style/media_quieres.rs, selectors.rs, stylesheets.rs

src/components/style/media_queries.rs

@@ -14,14 +14,14 @@ use url::Url;
 
 pub struct MediaRule {
     pub media_queries: MediaQueryList,
-    pub rules: ~[CSSRule],
+    pub rules: Vec<CSSRule>,
 }
 
 
 pub struct MediaQueryList {
     // "not all" is omitted from the list.
     // An empty list never matches.
-    media_queries: ~[MediaQuery]
+    media_queries: Vec<MediaQuery>
 }
 
 // For now, this is a "Level 2 MQ", ie. a media type.
@@ -48,7 +48,7 @@ pub struct Device {
 }
 
 
-pub fn parse_media_rule(rule: AtRule, parent_rules: &mut ~[CSSRule],
+pub fn parse_media_rule(rule: AtRule, parent_rules: &mut Vec<CSSRule>,
                         namespaces: &NamespaceMap, base_url: &Url) {
     let media_queries = parse_media_query_list(rule.prelude);
     let block = match rule.block {
@@ -58,7 +58,7 @@ pub fn parse_media_rule(rule: AtRule, parent_rules: &mut ~[CSSRule],
             return
         }
     };
-    let mut rules = ~[];
+    let mut rules = Vec::new();
     for rule in ErrorLoggerIterator(parse_rule_list(block.move_iter())) {
         match rule {
             QualifiedRule(rule) => parse_style_rule(rule, &mut rules, namespaces, base_url),
@@ -77,9 +77,9 @@ pub fn parse_media_query_list(input: &[ComponentValue]) -> MediaQueryList {
     let iter = &mut input.skip_whitespace();
     let mut next = iter.next();
     if next.is_none() {
-        return MediaQueryList{ media_queries: ~[MediaQuery{media_type: All}] }
+        return MediaQueryList{ media_queries: vec!(MediaQuery{media_type: All}) }
     }
-    let mut queries = ~[];
+    let mut queries = Vec::new();
     loop {
         let mq = match next {
             Some(&Ident(ref value)) => {

src/components/style/selectors.rs

@@ -112,13 +112,13 @@ type Iter = iter::Peekable<ComponentValue, slice::MoveItems<ComponentValue>>;
 ///
 /// Return the Selectors or None if there is an invalid selector.
 pub fn parse_selector_list(input: ~[ComponentValue], namespaces: &NamespaceMap)
-                           -> Option<~[Selector]> {
+                           -> Option<Vec<Selector>> {
     let iter = &mut input.move_iter().peekable();
     let first = match parse_selector(iter, namespaces) {
         None => return None,
         Some(result) => result
     };
-    let mut results = ~[first];
+    let mut results = vec!(first);
 
     loop {
         skip_whitespace(iter);

src/components/style/stylesheets.rs

@@ -21,7 +21,7 @@ use media_queries;
 pub struct Stylesheet {
     /// List of rules in the order they were found (important for
     /// cascading order)
-    pub rules: ~[CSSRule],
+    pub rules: Vec<CSSRule>,
     namespaces: NamespaceMap,
     encoding: EncodingRef,
     base_url: Url,
@@ -35,7 +35,7 @@ pub enum CSSRule {
 
 
 pub struct StyleRule {
-    pub selectors: ~[selectors::Selector],
+    pub selectors: Vec<selectors::Selector>,
     pub declarations: properties::PropertyDeclarationBlock,
 }
 
@@ -44,19 +44,20 @@ impl Stylesheet {
     pub fn from_bytes_iter<I: Iterator<Vec<u8>>>(
             mut input: I, base_url: Url, protocol_encoding_label: Option<&str>,
             environment_encoding: Option<EncodingRef>) -> Stylesheet {
-        let mut bytes = ~[];
+        let mut bytes = Vec::new(); 
         // TODO: incremental decoding and tokinization/parsing
         for chunk in input {
             bytes.push_all(chunk.as_slice())
         }
-        Stylesheet::from_bytes(bytes, base_url, protocol_encoding_label, environment_encoding)
+        Stylesheet::from_bytes(bytes.as_slice(), base_url, protocol_encoding_label, environment_encoding)
     }
 
     pub fn from_bytes(
             bytes: &[u8], base_url: Url, protocol_encoding_label: Option<&str>,
             environment_encoding: Option<EncodingRef>) -> Stylesheet {
+        // TODO: bytes.as_slice could be bytes.container_as_bytes()
         let (string, used_encoding) = decode_stylesheet_bytes(
-            bytes, protocol_encoding_label, environment_encoding);
+            bytes.as_slice(), protocol_encoding_label, environment_encoding);
         Stylesheet::from_str(string, base_url, used_encoding)
     }
 
@@ -67,7 +68,7 @@ impl Stylesheet {
         static STATE_BODY: uint = 4;
         let mut state: uint = STATE_CHARSET;
 
-        let mut rules = ~[];
+        let mut rules = Vec::new();
         let mut namespaces = NamespaceMap::new();
 
         for rule in ErrorLoggerIterator(parse_stylesheet_rules(tokenize(css))) {
@@ -124,7 +125,7 @@ impl Stylesheet {
 }
 
 
-pub fn parse_style_rule(rule: QualifiedRule, parent_rules: &mut ~[CSSRule],
+pub fn parse_style_rule(rule: QualifiedRule, parent_rules: &mut Vec<CSSRule>,
                         namespaces: &NamespaceMap, base_url: &Url) {
     let QualifiedRule{location: location, prelude: prelude, block: block} = rule;
     // FIXME: avoid doing this for valid selectors
@@ -142,7 +143,7 @@ pub fn parse_style_rule(rule: QualifiedRule, parent_rules: &mut ~[CSSRule],
 
 // lower_name is passed explicitly to avoid computing it twice.
 pub fn parse_nested_at_rule(lower_name: &str, rule: AtRule,
-                            parent_rules: &mut ~[CSSRule], namespaces: &NamespaceMap, base_url: &Url) {
+                            parent_rules: &mut Vec<CSSRule>, namespaces: &NamespaceMap, base_url: &Url) {
     match lower_name {
         "media" => parse_media_rule(rule, parent_rules, namespaces, base_url),
         _ => log_css_error(rule.location, format!("Unsupported at-rule: @{:s}", lower_name))