Auto merge of #5847 - Ms2ger:slice, r=SimonSapin

<!-- Reviewable:start -->
[<img src="https://reviewable.io/review_button.png" height=40 alt="Review on Reviewable"/>](https://reviewable.io/reviews/servo/servo/5847)
<!-- Reviewable:end -->

components/canvas/canvas_paint_task.rs

@@ -516,7 +516,7 @@ impl<'a> CanvasPaintTask<'a> {
         let mut dest_data = self.read_pixels(dest_rect, canvas_size);
 
         // bgra -> rgba
-        byte_swap(dest_data.as_mut_slice());
+        byte_swap(&mut dest_data);
         chan.send(dest_data).unwrap();
     }
 
@@ -530,7 +530,7 @@ impl<'a> CanvasPaintTask<'a> {
 
         assert!(image_data_rect.size.width * image_data_rect.size.height * 4.0 == imagedata.len() as f64);
         // rgba -> bgra
-        byte_swap(imagedata.as_mut_slice());
+        byte_swap(&mut imagedata);
 
         let image_rect = Rect(Point2D(0f64, 0f64),
                                Size2D(image_data_rect.size.width, image_data_rect.size.height));

components/canvas/webgl_paint_task.rs

@@ -100,7 +100,7 @@ impl WebGLPaintTask {
                                     gl::RGBA, gl::UNSIGNED_BYTE);
 
         // rgba -> bgra
-        byte_swap(pixels.as_mut_slice());
+        byte_swap(&mut pixels);
         chan.send(pixels).unwrap();
     }
 

components/layout/table_wrapper.rs

@@ -288,7 +288,7 @@ impl Flow for TableWrapperFlow {
             TableLayout::Fixed => {}
             TableLayout::Auto => {
                 self.calculate_table_column_sizes_for_automatic_layout(
-                    intermediate_column_inline_sizes.as_mut_slice())
+                    &mut intermediate_column_inline_sizes)
             }
         }
 

components/net/file_loader.rs

@@ -23,7 +23,7 @@ enum ReadStatus {
 
 fn read_block(reader: &mut File) -> Result<ReadStatus, String> {
     let mut buf = vec![0; READ_SIZE];
-    match reader.read(buf.as_mut_slice()) {
+    match reader.read(&mut buf) {
         Ok(0) => return Ok(ReadStatus::EOF),
         Ok(n) => {
             buf.truncate(n);

components/net/http_loader.rs

@@ -56,7 +56,7 @@ enum ReadResult {
 fn read_block<R: Read>(reader: &mut R) -> Result<ReadResult, ()> {
     let mut buf = vec![0; 1024];
 
-    match reader.read(buf.as_mut_slice()) {
+    match reader.read(&mut buf) {
         Ok(len) if len > 0 => {
             unsafe { buf.set_len(len); }
             Ok(ReadResult::Payload(buf))

components/script/dom/attr.rs

@@ -51,7 +51,7 @@ impl AttrValue {
     }
 
     pub fn from_atomic_tokens(atoms: Vec<Atom>) -> AttrValue {
-        let tokens = atoms.iter().map(Atom::as_slice).collect::<Vec<_>>().connect("\x20");
+        let tokens = atoms.iter().map(|x| &**x).collect::<Vec<_>>().connect("\x20");
         AttrValue::TokenList(tokens, atoms)
     }
 
@@ -67,7 +67,7 @@ impl AttrValue {
 
     pub fn tokens<'a>(&'a self) -> Option<&'a [Atom]> {
         match *self {
-            AttrValue::TokenList(_, ref tokens) => Some(tokens.as_slice()),
+            AttrValue::TokenList(_, ref tokens) => Some(tokens),
             _ => None
         }
     }
@@ -149,7 +149,7 @@ impl Attr {
 impl<'a> AttrMethods for JSRef<'a, Attr> {
     // https://dom.spec.whatwg.org/#dom-attr-localname
     fn LocalName(self) -> DOMString {
-        self.local_name().as_slice().to_owned()
+        (**self.local_name()).to_owned()
     }
 
     // https://dom.spec.whatwg.org/#dom-attr-value
@@ -191,13 +191,13 @@ impl<'a> AttrMethods for JSRef<'a, Attr> {
 
     // https://dom.spec.whatwg.org/#dom-attr-name
     fn Name(self) -> DOMString {
-        self.name.as_slice().to_owned()
+        (*self.name).to_owned()
     }
 
     // https://dom.spec.whatwg.org/#dom-attr-namespaceuri
     fn GetNamespaceURI(self) -> Option<DOMString> {
         let Namespace(ref atom) = self.namespace;
-        match atom.as_slice() {
+        match &**atom {
             "" => None,
             url => Some(url.to_owned()),
         }
@@ -281,7 +281,7 @@ impl<'a> AttrHelpers<'a> for JSRef<'a, Attr> {
     fn summarize(self) -> AttrInfo {
         let Namespace(ref ns) = self.namespace;
         AttrInfo {
-            namespace: ns.as_slice().to_owned(),
+            namespace: (**ns).to_owned(),
             name: self.Name(),
             value: self.Value(),
         }
@@ -319,7 +319,7 @@ impl AttrHelpersForLayout for Attr {
         // This transmute is used to cheat the lifetime restriction.
         let value = mem::transmute::<&AttrValue, &AttrValue>(self.value.borrow_for_layout());
         match *value {
-            AttrValue::TokenList(_, ref tokens) => Some(tokens.as_slice()),
+            AttrValue::TokenList(_, ref tokens) => Some(tokens),
             _ => None,
         }
     }

components/script/dom/bindings/conversions.rs

@@ -312,7 +312,7 @@ impl ToJSValConvertible for str {
 
 impl ToJSValConvertible for DOMString {
     fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
-        self.as_slice().to_jsval(cx)
+        (**self).to_jsval(cx)
     }
 }
 

components/script/dom/bindings/str.rs

@@ -30,7 +30,7 @@ impl ByteString {
     /// Returns the underlying vector as a slice.
     pub fn as_slice<'a>(&'a self) -> &'a [u8] {
         let ByteString(ref vector) = *self;
-        vector.as_slice()
+        vector
     }
 
     /// Returns the length.

components/script/dom/blob.rs

@@ -70,12 +70,11 @@ impl Blob {
         //TODO: accept other blobParts types - ArrayBuffer or ArrayBufferView or Blob
         let bytes: Option<Vec<u8>> = Some(blobParts.into_bytes());
         let typeString = if is_ascii_printable(&blobPropertyBag.type_) {
-            blobPropertyBag.type_.as_slice()
+            &*blobPropertyBag.type_
         } else {
             ""
         };
-        let typeStrLower = typeString.as_slice().to_ascii_lowercase();
+        Ok(Blob::new(global, bytes, &typeString.to_ascii_lowercase()))
-        Ok(Blob::new(global, bytes, typeStrLower.as_slice()))
     }
 }
 
@@ -121,7 +120,7 @@ impl<'a> BlobMethods for JSRef<'a, Blob> {
             None => "".to_owned(),
             Some(str) => {
                 if is_ascii_printable(&str) {
-                    str.as_slice().to_ascii_lowercase().to_owned()
+                    str.to_ascii_lowercase()
                 } else {
                     "".to_owned()
                 }
@@ -130,13 +129,13 @@ impl<'a> BlobMethods for JSRef<'a, Blob> {
         let span: i64 = max(relativeEnd - relativeStart, 0);
         let global = self.global.root();
         match self.bytes {
-            None => Blob::new(global.r(), None, relativeContentType.as_slice()),
+            None => Blob::new(global.r(), None, &relativeContentType),
             Some(ref vec) => {
                 let start = relativeStart.to_usize().unwrap();
                 let end = (relativeStart + span).to_usize().unwrap();
                 let mut bytes: Vec<u8> = Vec::new();
                 bytes.push_all(&vec[start..end]);
-                Blob::new(global.r(), Some(bytes), relativeContentType.as_slice())
+                Blob::new(global.r(), Some(bytes), &relativeContentType)
             }
         }
     }

components/script/dom/canvasrenderingcontext2d.rs

@@ -264,10 +264,7 @@ impl CanvasRenderingContext2D {
         };
         // Pixels come from cache in BGRA order and drawImage expects RGBA so we
         // have to swap the color values
-        {
+        byte_swap(&mut image_data);
-            let mut pixel_colors = image_data.as_mut_slice();
-            byte_swap(pixel_colors);
-        }
         return Some((image_data, image_size));
     }
 

components/script/dom/characterdata.rs

@@ -112,7 +112,7 @@ impl<'a> CharacterDataMethods for JSRef<'a, CharacterData> {
             count
         };
         let mut data = self.data.borrow().slice_chars(0, offset as usize).to_owned();
-        data.push_str(arg.as_slice());
+        data.push_str(&arg);
         data.push_str(&self.data.borrow().slice_chars((offset + count) as usize, length as usize));
         *self.data.borrow_mut() = data;
         // FIXME: Once we have `Range`, we should implement step7 to step11

components/script/dom/console.rs

@@ -72,7 +72,7 @@ impl<'a> ConsoleMethods for JSRef<'a, Console> {
     fn Assert(self, condition: bool, message: Option<DOMString>) {
         if !condition {
             let message = match message {
-                Some(ref message) => message.as_slice(),
+                Some(ref message) => &**message,
                 None => "no message",
             };
             println!("Assertion failed: {}", message);

components/script/dom/create.rs

@@ -86,16 +86,16 @@ pub fn create_element(name: QualName, prefix: Option<DOMString>,
                       document: JSRef<Document>, creator: ElementCreator)
                       -> Temporary<Element> {
     if name.ns != ns!(HTML) {
-        return Element::new(name.local.as_slice().to_owned(), name.ns, prefix, document);
+        return Element::new((*name.local).to_owned(), name.ns, prefix, document);
     }
 
     macro_rules! make(
         ($ctor:ident) => ({
-            let obj = $ctor::new(name.local.as_slice().to_owned(), prefix, document);
+            let obj = $ctor::new((*name.local).to_owned(), prefix, document);
             ElementCast::from_temporary(obj)
         });
         ($ctor:ident, $($arg:expr),+) => ({
-            let obj = $ctor::new(name.local.as_slice().to_owned(), prefix, document, $($arg),+);
+            let obj = $ctor::new((*name.local).to_owned(), prefix, document, $($arg),+);
             ElementCast::from_temporary(obj)
         })
     );

components/script/dom/document.rs

@@ -1120,7 +1120,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
     fn CreateEvent(self, interface: DOMString) -> Fallible<Temporary<Event>> {
         let window = self.window.root();
 
-        match interface.to_ascii_lowercase().as_slice() {
+        match &*interface.to_ascii_lowercase() {
             "uievents" | "uievent" => Ok(EventCast::from_temporary(
                 UIEvent::new_uninitialized(window.r()))),
             "mouseevents" | "mouseevent" => Ok(EventCast::from_temporary(

components/script/dom/domtokenlist.rs

@@ -81,7 +81,7 @@ impl<'a> DOMTokenListMethods for JSRef<'a, DOMTokenList> {
             let attr = attr.r();
             let value = attr.value();
             value.tokens().and_then(|tokens| {
-                tokens.get(index as usize).map(|token| token.as_slice().to_owned())
+                tokens.get(index as usize).map(|token| (**token).to_owned())
             })
         })
     }

components/script/dom/element.rs

@@ -477,7 +477,7 @@ impl<'a> ElementHelpers<'a> for JSRef<'a, Element> {
         if self.namespace != ns!(HTML) {
             return false
         }
-        match self.local_name.as_slice() {
+        match &*self.local_name {
             /* List of void elements from
             https://html.spec.whatwg.org/multipage/#html-fragment-serialisation-algorithm */
             "area" | "base" | "basefont" | "bgsound" | "br" | "col" | "embed" |
@@ -752,7 +752,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         let name = match prefix {
             None => qname.local.clone(),
             Some(ref prefix) => {
-                let name = format!("{}:{}", *prefix, qname.local.as_slice());
+                let name = format!("{}:{}", *prefix, &*qname.local);
                 Atom::from_slice(&name)
             },
         };
@@ -761,7 +761,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
     }
 
     fn set_attribute(self, name: &Atom, value: AttrValue) {
-        assert!(name.as_slice() == name.to_ascii_lowercase());
+        assert!(&**name == name.to_ascii_lowercase());
         assert!(!name.contains(":"));
 
         self.do_set_attribute(name.clone(), value, name.clone(),
@@ -883,7 +883,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
     }
 
     fn set_atomic_attribute(self, local_name: &Atom, value: DOMString) {
-        assert!(local_name.as_slice() == local_name.to_ascii_lowercase());
+        assert!(&**local_name == local_name.to_ascii_lowercase());
         let value = AttrValue::from_atomic(value);
         self.set_attribute(local_name, value);
     }
@@ -909,7 +909,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
     }
 
     fn get_url_attribute(self, local_name: &Atom) -> DOMString {
-        assert!(local_name.as_slice() == local_name.to_ascii_lowercase());
+        assert!(&**local_name == local_name.to_ascii_lowercase());
         if !self.has_attribute(local_name) {
             return "".to_owned();
         }
@@ -934,7 +934,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         }
     }
     fn set_string_attribute(self, local_name: &Atom, value: DOMString) {
-        assert!(local_name.as_slice() == local_name.to_ascii_lowercase());
+        assert!(&**local_name == local_name.to_ascii_lowercase());
         self.set_attribute(local_name, AttrValue::String(value));
     }
 
@@ -950,12 +950,12 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
     }
 
     fn set_tokenlist_attribute(self, local_name: &Atom, value: DOMString) {
-        assert!(local_name.as_slice() == local_name.to_ascii_lowercase());
+        assert!(&**local_name == local_name.to_ascii_lowercase());
         self.set_attribute(local_name, AttrValue::from_serialized_tokenlist(value));
     }
 
     fn set_atomic_tokenlist_attribute(self, local_name: &Atom, tokens: Vec<Atom>) {
-        assert!(local_name.as_slice() == local_name.to_ascii_lowercase());
+        assert!(&**local_name == local_name.to_ascii_lowercase());
         self.set_attribute(local_name, AttrValue::from_atomic_tokens(tokens));
     }
 
@@ -976,7 +976,7 @@ impl<'a> AttributeHandlers for JSRef<'a, Element> {
         }
     }
     fn set_uint_attribute(self, local_name: &Atom, value: u32) {
-        assert!(local_name.as_slice() == local_name.to_ascii_lowercase());
+        assert!(&**local_name == local_name.to_ascii_lowercase());
         self.set_attribute(local_name, AttrValue::UInt(value.to_string(), value));
     }
 }
@@ -986,13 +986,13 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     fn GetNamespaceURI(self) -> Option<DOMString> {
         match self.namespace {
             ns!("") => None,
-            Namespace(ref ns) => Some(ns.as_slice().to_owned())
+            Namespace(ref ns) => Some((**ns).to_owned())
         }
     }
 
     // https://dom.spec.whatwg.org/#dom-element-localname
     fn LocalName(self) -> DOMString {
-        self.local_name.as_slice().to_owned()
+        (*self.local_name).to_owned()
     }
 
     // https://dom.spec.whatwg.org/#dom-element-prefix
@@ -1004,11 +1004,9 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     fn TagName(self) -> DOMString {
         let qualified_name = match self.prefix {
             Some(ref prefix) => {
-                (format!("{}:{}",
+                (format!("{}:{}", &**prefix, &*self.local_name)).into_cow()
-                         prefix.as_slice(),
-                         self.local_name.as_slice())).into_cow()
             },
-            None => self.local_name.as_slice().into_cow()
+            None => self.local_name.into_cow()
         };
         if self.html_element_in_html_document() {
             qualified_name.to_ascii_uppercase()

components/script/dom/eventdispatcher.rs

@@ -42,9 +42,9 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
     //FIXME: The "callback this value" should be currentTarget
 
     /* capturing */
-    for cur_target in chain.as_slice().iter().rev() {
+    for cur_target in chain.iter().rev() {
         let cur_target = cur_target.root();
-        let stopped = match cur_target.r().get_listeners_for(type_.as_slice(), ListenerPhase::Capturing) {
+        let stopped = match cur_target.r().get_listeners_for(&type_, ListenerPhase::Capturing) {
             Some(listeners) => {
                 event.set_current_target(cur_target.r());
                 for listener in listeners.iter() {
@@ -71,7 +71,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
         event.set_phase(EventPhase::AtTarget);
         event.set_current_target(target.clone());
 
-        let opt_listeners = target.get_listeners(type_.as_slice());
+        let opt_listeners = target.get_listeners(&type_);
         for listeners in opt_listeners.iter() {
             for listener in listeners.iter() {
                 // Explicitly drop any exception on the floor.
@@ -90,7 +90,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
 
         for cur_target in chain.iter() {
             let cur_target = cur_target.root();
-            let stopped = match cur_target.r().get_listeners_for(type_.as_slice(), ListenerPhase::Bubbling) {
+            let stopped = match cur_target.r().get_listeners_for(&type_, ListenerPhase::Bubbling) {
                 Some(listeners) => {
                     event.set_current_target(cur_target.r());
                     for listener in listeners.iter() {

components/script/dom/eventtarget.rs

@@ -207,7 +207,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
             ['e' as c_char, 'v' as c_char, 'e' as c_char, 'n' as c_char, 't' as c_char, 0];
         static mut ARG_NAMES: [*const c_char; 1] = [&ARG_NAME as *const c_char];
 
-        let source: Vec<u16> = source.as_slice().utf16_units().collect();
+        let source: Vec<u16> = source.utf16_units().collect();
         let handler = unsafe {
             JS_CompileUCFunction(cx,
                                  ptr::null_mut(),
@@ -269,7 +269,7 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
                     phase: phase,
                     listener: EventListenerType::Additive(listener)
                 };
-                if entry.as_slice().position_elem(&new_entry).is_none() {
+                if entry.position_elem(&new_entry).is_none() {
                     entry.push(new_entry);
                 }
             },
@@ -291,7 +291,7 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
                         phase: phase,
                         listener: EventListenerType::Additive(listener)
                     };
-                    let position = entry.as_slice().position_elem(&old_entry);
+                    let position = entry.position_elem(&old_entry);
                     for &position in position.iter() {
                         entry.remove(position);
                     }

components/script/dom/htmlbodyelement.rs

@@ -89,7 +89,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
             s.after_set_attr(attr);
         }
 
-        let name = attr.local_name().as_slice();
+        let name = attr.local_name();
         if name.starts_with("on") {
             static FORWARDED_EVENTS: &'static [&'static str] =
                 &["onfocus", "onload", "onscroll", "onafterprint", "onbeforeprint",
@@ -101,7 +101,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
                                         window.r().get_url(),
                                         window.r().reflector().get_jsobject());
             let evtarget: JSRef<EventTarget> =
-                if FORWARDED_EVENTS.iter().any(|&event| name == event) {
+                if FORWARDED_EVENTS.iter().any(|&event| &**name == event) {
                     EventTargetCast::from_ref(window.r())
                 } else {
                     EventTargetCast::from_ref(*self)

components/script/dom/htmlbuttonelement.rs

@@ -83,7 +83,7 @@ impl<'a> HTMLButtonElementMethods for JSRef<'a, HTMLButtonElement> {
         let elem: JSRef<Element> = ElementCast::from_ref(self);
         let ty = elem.get_string_attribute(&atom!("type")).into_ascii_lowercase();
         // https://html.spec.whatwg.org/multipage/#attr-button-type
-        match ty.as_slice() {
+        match &*ty {
             "reset" | "button" | "menu" => ty,
             _ => "submit".to_owned()
         }

components/script/dom/htmlcanvaselement.rs

@@ -168,7 +168,7 @@ impl<'a> HTMLCanvasElementMethods for JSRef<'a, HTMLCanvasElement> {
     }
 
     fn GetContext(self, id: DOMString) -> Option<CanvasRenderingContext2DOrWebGLRenderingContext> {
-        match id.as_slice() {
+        match &*id {
            "2d" => {
                let context_2d = self.context_2d.or_init(|| {
                    let window = window_from_node(self).root();

components/script/dom/htmlcollection.rs

@@ -193,7 +193,6 @@ impl<'a> HTMLCollectionMethods for JSRef<'a, HTMLCollection> {
         let index = index as usize;
         match self.collection {
             CollectionTypeId::Static(ref elems) => elems
-                .as_slice()
                 .get(index)
                 .map(|elem| Temporary::new(elem.clone())),
             CollectionTypeId::Live(ref root, ref filter) => {

components/script/dom/htmlelement.rs

@@ -186,7 +186,7 @@ fn to_snake_case(name: DOMString) -> DOMString {
 
 impl<'a> HTMLElementCustomAttributeHelpers for JSRef<'a, HTMLElement> {
     fn set_custom_attr(self, name: DOMString, value: DOMString) -> ErrorResult {
-        if name.as_slice().chars()
+        if name.chars()
                .skip_while(|&ch| ch != '\u{2d}')
                .nth(1).map_or(false, |ch| ch >= 'a' && ch <= 'z') {
             return Err(Syntax);

components/script/dom/htmlfieldsetelement.rs

@@ -56,7 +56,7 @@ impl<'a> HTMLFieldSetElementMethods for JSRef<'a, HTMLFieldSetElement> {
             fn filter<'a>(&self, elem: JSRef<'a, Element>, _root: JSRef<'a, Node>) -> bool {
                 static TAG_NAMES: StaticStringVec = &["button", "fieldset", "input",
                     "keygen", "object", "output", "select", "textarea"];
-                TAG_NAMES.iter().any(|&tag_name| tag_name == elem.local_name().as_slice())
+                TAG_NAMES.iter().any(|&tag_name| tag_name == &**elem.local_name())
             }
         }
         let node: JSRef<Node> = NodeCast::from_ref(self);

components/script/dom/htmlformelement.rs

@@ -180,7 +180,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         }
         // TODO: Resolve the url relative to the submitter element
         // Step 10-15
-        let action_components = UrlParser::new().base_url(&base).parse(action.as_slice()).unwrap_or(base);
+        let action_components = UrlParser::new().base_url(&base).parse(&action).unwrap_or(base);
         let _action = action_components.serialize();
         let scheme = action_components.scheme.clone();
         let enctype = submitter.enctype();
@@ -194,13 +194,13 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
             FormEncType::UrlEncoded => {
                 let mime: mime::Mime = "application/x-www-form-urlencoded".parse().unwrap();
                 load_data.headers.set(ContentType(mime));
-                serialize(form_data.iter().map(|d| (d.name.as_slice(), d.value.as_slice())))
+                serialize(form_data.iter().map(|d| (&*d.name, &*d.value)))
             }
             _ => "".to_owned() // TODO: Add serializers for the other encoding types
         };
 
         // Step 18
-        match (scheme.as_slice(), method) {
+        match (&*scheme, method) {
             (_, FormMethod::FormDialog) => return, // Unimplemented
             ("http", FormMethod::FormGet) | ("https", FormMethod::FormGet) => {
                 load_data.url.query = Some(parsed_data);
@@ -269,7 +269,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
                     let input = HTMLInputElementCast::to_ref(child.r()).unwrap();
                     let ty = input.Type();
                     let name = input.Name();
-                    match ty.as_slice() {
+                    match &*ty {
                         "radio" | "checkbox" => {
                             if !input.Checked() || name.is_empty() {
                                 return None;
@@ -290,7 +290,7 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
                         },
                         _ => false
                     };
-                    match ty.as_slice() {
+                    match &*ty {
                         "image" => None, // Unimplemented
                         "radio" | "checkbox" => {
                             if value.is_empty() {
@@ -335,11 +335,11 @@ impl<'a> HTMLFormElementHelpers for JSRef<'a, HTMLFormElement> {
         //       https://html.spec.whatwg.org/multipage/#the-directionality
         let mut ret: Vec<FormDatum> = data_set.collect();
         for datum in ret.iter_mut() {
-            match datum.ty.as_slice() {
+            match &*datum.ty {
                 "file" | "textarea" => (),
                 _ => {
-                    datum.name = clean_crlf(datum.name.as_slice());
+                    datum.name = clean_crlf(&datum.name);
-                    datum.value = clean_crlf(datum.value.as_slice());
+                    datum.value = clean_crlf(&datum.value);
                 }
             }
         };
@@ -462,7 +462,7 @@ impl<'a> FormSubmitter<'a> {
                                                   |f| f.Action())
             }
         };
-        match attr.as_slice() {
+        match &*attr {
             "multipart/form-data" => FormEncType::FormDataEncoded,
             "text/plain" => FormEncType::TextPlainEncoded,
             // https://html.spec.whatwg.org/multipage/#attr-fs-enctype
@@ -486,7 +486,7 @@ impl<'a> FormSubmitter<'a> {
                                                   |f| f.Action())
             }
         };
-        match attr.as_slice() {
+        match &*attr {
             "dialog" => FormMethod::FormDialog,
             "post" => FormMethod::FormPost,
             _ => FormMethod::FormGet

components/script/dom/htmliframeelement.rs

@@ -335,7 +335,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLIFrameElement> {
                 let mut modes = SandboxAllowance::AllowNothing as u8;
                 if let Some(ref tokens) = attr.value().tokens() {
                     for token in tokens.iter() {
-                        modes |= match token.as_slice().to_ascii_lowercase().as_slice() {
+                        modes |= match &*token.to_ascii_lowercase() {
                             "allow-same-origin" => SandboxAllowance::AllowSameOrigin,
                             "allow-forms" => SandboxAllowance::AllowForms,
                             "allow-pointer-lock" => SandboxAllowance::AllowPointerLock,

components/script/dom/htmlimageelement.rs

@@ -116,7 +116,7 @@ impl<'a> PrivateHTMLImageElementHelpers for JSRef<'a, HTMLImageElement> {
                 *self.image.borrow_mut() = None;
             }
             Some((src, base_url)) => {
-                let img_url = UrlParser::new().base_url(base_url).parse(src.as_slice());
+                let img_url = UrlParser::new().base_url(base_url).parse(&src);
                 // FIXME: handle URL parse errors more gracefully.
                 let img_url = img_url.unwrap();
                 *self.url.borrow_mut() = Some(img_url.clone());

components/script/dom/htmlinputelement.rs

@@ -372,7 +372,7 @@ fn in_same_group<'a,'b>(other: JSRef<'a, HTMLInputElement>,
     other_owner.equals(owner) &&
     // TODO should be a unicode compatibility caseless match
     match (other.get_radio_group_name(), group) {
-        (Some(ref s1), Some(s2)) => s1.as_slice() == s2,
+        (Some(ref s1), Some(s2)) => &**s1 == s2,
         (None, None) => true,
         _ => false
     }
@@ -410,7 +410,7 @@ impl<'a> HTMLInputElementHelpers for JSRef<'a, HTMLInputElement> {
             broadcast_radio_checked(self,
                                     self.get_radio_group_name()
                                         .as_ref()
-                                        .map(|group| group.as_slice()));
+                                        .map(|group| &**group));
         }
         //TODO: dispatch change event
     }
@@ -492,7 +492,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
                 if self.input_type.get() == InputType::InputRadio {
                     self.radio_group_updated(self.get_radio_group_name()
                                                  .as_ref()
-                                                 .map(|group| group.as_slice()));
+                                                 .map(|group| &**group));
                 }
             }
             &atom!("value") => {
@@ -543,7 +543,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
                     broadcast_radio_checked(*self,
                                             self.get_radio_group_name()
                                                 .as_ref()
-                                                .map(|group| group.as_slice()));
+                                                .map(|group| &**group));
                 }
                 self.input_type.set(InputType::InputText);
             }
@@ -598,7 +598,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
             s.handle_event(event);
         }
 
-        if "click" == event.Type().as_slice() && !event.DefaultPrevented() {
+        if &*event.Type() == "click" && !event.DefaultPrevented() {
             match self.input_type.get() {
                 InputType::InputRadio => self.update_checked_state(true, true),
                 _ => {}
@@ -611,7 +611,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLInputElement> {
 
             let doc = document_from_node(*self).root();
             doc.r().request_focus(ElementCast::from_ref(*self));
-        } else if "keydown" == event.Type().as_slice() && !event.DefaultPrevented() &&
+        } else if &*event.Type() == "keydown" && !event.DefaultPrevented() &&
             (self.input_type.get() == InputType::InputText ||
              self.input_type.get() == InputType::InputPassword) {
                 let keyevent: Option<JSRef<KeyboardEvent>> = KeyboardEventCast::to_ref(event);
@@ -690,7 +690,7 @@ impl<'a> Activatable for JSRef<'a, HTMLInputElement> {
                                 .filter_map(HTMLInputElementCast::to_temporary)
                                 .map(|t| t.root())
                                 .find(|r| {
-                                    in_same_group(r.r(), owner.r(), group.as_ref().map(|gr| gr.as_slice())) &&
+                                    in_same_group(r.r(), owner.r(), group.as_ref().map(|gr| &**gr)) &&
                                     r.r().Checked()
                                 })
                     };

components/script/dom/htmllinkelement.rs

@@ -70,8 +70,8 @@ fn get_attr(element: JSRef<Element>, local_name: &Atom) -> Option<String> {
 fn is_stylesheet(value: &Option<String>) -> bool {
     match *value {
         Some(ref value) => {
-            value.as_slice().split(HTML_SPACE_CHARACTERS.as_slice())
+            value.split(HTML_SPACE_CHARACTERS)
-                .any(|s| s.as_slice().eq_ignore_ascii_case("stylesheet"))
+                .any(|s| s.eq_ignore_ascii_case("stylesheet"))
         },
         None => false,
     }
@@ -126,7 +126,7 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLLinkElement> {
 
             match (rel, href) {
                 (ref rel, Some(ref href)) if is_stylesheet(rel) => {
-                    self.handle_stylesheet_url(href.as_slice());
+                    self.handle_stylesheet_url(href);
                 }
                 _ => {}
             }

components/script/dom/htmloptionelement.rs

@@ -51,7 +51,7 @@ impl HTMLOptionElement {
 
 fn collect_text(node: &JSRef<Node>, value: &mut DOMString) {
     let elem: JSRef<Element> = ElementCast::to_ref(*node).unwrap();
-    let svg_script = *elem.namespace() == ns!(SVG) && elem.local_name().as_slice() == "script";
+    let svg_script = *elem.namespace() == ns!(SVG) && elem.local_name() == &atom!("script");
     let html_script = node.is_htmlscriptelement();
     if svg_script || html_script {
         return;
@@ -60,7 +60,7 @@ fn collect_text(node: &JSRef<Node>, value: &mut DOMString) {
             let child = child.root();
             if child.r().is_text() {
                 let characterdata: JSRef<CharacterData> = CharacterDataCast::to_ref(child.r()).unwrap();
-                value.push_str(characterdata.Data().as_slice());
+                value.push_str(&characterdata.Data());
             } else {
                 collect_text(&child.r(), value);
             }
@@ -83,7 +83,7 @@ impl<'a> HTMLOptionElementMethods for JSRef<'a, HTMLOptionElement> {
         let node: JSRef<Node> = NodeCast::from_ref(self);
         let mut content = String::new();
         collect_text(&node, &mut content);
-        let v: Vec<&str> = split_html_space_chars(content.as_slice()).collect();
+        let v: Vec<&str> = split_html_space_chars(&content).collect();
         v.connect(" ")
     }
 

components/script/dom/htmlscriptelement.rs

@@ -414,7 +414,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
             },
             Some(ref s) => {
                 debug!("script type={}", *s);
-                SCRIPT_JS_MIMES.contains(&s.to_ascii_lowercase().as_slice().trim_matches(HTML_SPACE_CHARACTERS))
+                SCRIPT_JS_MIMES.contains(&s.to_ascii_lowercase().trim_matches(HTML_SPACE_CHARACTERS))
             },
             None => {
                 debug!("no script type");
@@ -427,7 +427,7 @@ impl<'a> HTMLScriptElementHelpers for JSRef<'a, HTMLScriptElement> {
                     },
                     Some(ref s) => {
                         debug!("script language={}", *s);
-                        SCRIPT_JS_MIMES.contains(&format!("text/{}", s).to_ascii_lowercase().as_slice())
+                        SCRIPT_JS_MIMES.contains(&&*format!("text/{}", s).to_ascii_lowercase())
                     },
                     None => {
                         debug!("no script type or language, inferring js");

components/script/dom/htmlstyleelement.rs

@@ -64,7 +64,7 @@ impl<'a> StyleElementHelpers for JSRef<'a, HTMLStyleElement> {
         let media = parse_media_query_list(&mut css_parser);
 
         let data = node.GetTextContent().expect("Element.textContent must be a string");
-        let sheet = Stylesheet::from_str(data.as_slice(), url, Origin::Author);
+        let sheet = Stylesheet::from_str(&data, url, Origin::Author);
         let LayoutChan(ref layout_chan) = win.layout_chan();
         layout_chan.send(Msg::AddStylesheet(sheet, media)).unwrap();
     }

components/script/dom/htmltextareaelement.rs

@@ -344,12 +344,12 @@ impl<'a> VirtualMethods for JSRef<'a, HTMLTextAreaElement> {
             s.handle_event(event);
         }
 
-        if "click" == event.Type().as_slice() && !event.DefaultPrevented() {
+        if &*event.Type() == "click" && !event.DefaultPrevented() {
             //TODO: set the editing position for text inputs
 
             let doc = document_from_node(*self).root();
             doc.r().request_focus(ElementCast::from_ref(*self));
-        } else if "keydown" == event.Type().as_slice() && !event.DefaultPrevented() {
+        } else if &*event.Type() == "keydown" && !event.DefaultPrevented() {
             let keyevent: Option<JSRef<KeyboardEvent>> = KeyboardEventCast::to_ref(event);
             keyevent.map(|kevent| {
                 match self.textinput.borrow_mut().handle_keydown(kevent) {

components/script/dom/keyboardevent.rs

@@ -615,7 +615,7 @@ impl<'a> KeyboardEventMethods for JSRef<'a, KeyboardEvent> {
 
     // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#widl-KeyboardEvent-getModifierState
     fn GetModifierState(self, keyArg: DOMString) -> bool {
-        match keyArg.as_slice() {
+        match &*keyArg {
             "Ctrl" => self.CtrlKey(),
             "Alt" => self.AltKey(),
             "Shift" => self.ShiftKey(),

components/script/dom/macros.rs

@@ -85,7 +85,7 @@ macro_rules! make_url_or_base_getter(
             use std::ascii::AsciiExt;
             let element: JSRef<Element> = ElementCast::from_ref(self);
             let url = element.get_url_attribute(&Atom::from_slice($htmlname));
-            match url.as_slice() {
+            match &*url {
                 "" => {
                     let window = window_from_node(self).root();
                     window.r().get_url().serialize()
@@ -112,14 +112,14 @@ macro_rules! make_enumerated_getter(
             let val = element.get_string_attribute(&Atom::from_slice($htmlname))
                              .into_ascii_lowercase();
             // https://html.spec.whatwg.org/multipage/#attr-fs-method
-            match val.as_slice() {
+            match &*val {
                 $($choices)|+ => val,
                 _ => $default.to_owned()
             }
         }
     );
     ($attr:ident, $default:expr, $(($choices: pat))|+) => {
-        make_enumerated_getter!($attr, to_lower!(stringify!($attr)).as_slice(), $default, $(($choices))|+);
+        make_enumerated_getter!($attr, &to_lower!(stringify!($attr)), $default, $(($choices))|+);
     }
 );
 

components/script/dom/namednodemap.rs

@@ -52,7 +52,7 @@ impl<'a> NamedNodeMapMethods for JSRef<'a, NamedNodeMap> {
         // FIXME(https://github.com/rust-lang/rust/issues/23338)
         let owner = owner.r();
         let attrs = owner.attrs();
-        attrs.as_slice().get(index as usize).map(|x| Temporary::new(x.clone()))
+        attrs.get(index as usize).map(|x| Temporary::new(x.clone()))
     }
 
     // https://dom.spec.whatwg.org/#dom-namednodemap-getnameditem

components/script/dom/node.rs

@@ -544,7 +544,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
             s.push_str("    ");
         }
 
-        s.push_str(self.debug_str().as_slice());
+        s.push_str(&*self.debug_str());
         debug!("{:?}", s);
 
         // FIXME: this should have a pure version?
@@ -888,7 +888,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselector
     fn query_selector(self, selectors: DOMString) -> Fallible<Option<Temporary<Element>>> {
         // Step 1.
-        match parse_author_origin_selector_list_from_str(selectors.as_slice()) {
+        match parse_author_origin_selector_list_from_str(&selectors) {
             // Step 2.
             Err(()) => return Err(Syntax),
             // Step 3.
@@ -909,7 +909,7 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
     unsafe fn query_selector_iter(self, selectors: DOMString)
                                   -> Fallible<QuerySelectorIterator> {
         // Step 1.
-        match parse_author_origin_selector_list_from_str(selectors.as_slice()) {
+        match parse_author_origin_selector_list_from_str(&selectors) {
             // Step 2.
             Err(()) => Err(Syntax),
             // Step 3.
@@ -1734,7 +1734,7 @@ impl Node {
                     local: element.local_name().clone()
                 };
                 let element = Element::create(name,
-                    element.prefix().as_ref().map(|p| p.as_slice().to_owned()),
+                    element.prefix().as_ref().map(|p| (**p).to_owned()),
                     document.r(), ElementCreator::ScriptCreated);
                 NodeCast::from_temporary(element)
             },

components/script/dom/textencoder.rs

@@ -50,7 +50,7 @@ impl TextEncoder {
     // https://encoding.spec.whatwg.org/#dom-textencoder
     pub fn Constructor(global: GlobalRef,
                        label: DOMString) -> Fallible<Temporary<TextEncoder>> {
-        let encoding = match encoding_from_whatwg_label(label.trim().as_slice().to_ascii_lowercase().as_slice()) {
+        let encoding = match encoding_from_whatwg_label(&label.trim().to_ascii_lowercase()) {
             Some(enc) => enc,
             None => {
                 debug!("Encoding Label Not Supported");
@@ -80,7 +80,7 @@ impl<'a> TextEncoderMethods for JSRef<'a, TextEncoder> {
     #[allow(unsafe_code)]
     fn Encode(self, cx: *mut JSContext, input: USVString) -> *mut JSObject {
         unsafe {
-            let output = self.encoder.encode(input.0.as_slice(), EncoderTrap::Strict).unwrap();
+            let output = self.encoder.encode(&input.0, EncoderTrap::Strict).unwrap();
             let length = output.len() as u32;
             let js_object: *mut JSObject = JS_NewUint8Array(cx, length);
 

components/script/dom/urlhelper.rs

@@ -20,7 +20,7 @@ impl UrlHelper {
     pub fn Search(url: &Url) -> USVString {
         USVString(match url.query {
             None => "".to_owned(),
-            Some(ref query) if query.as_slice() == "" => "".to_owned(),
+            Some(ref query) if query.is_empty() => "".to_owned(),
             Some(ref query) => format!("?{}", query)
         })
     }
@@ -29,7 +29,7 @@ impl UrlHelper {
     pub fn Hash(url: &Url) -> USVString {
         USVString(match url.fragment {
             None => "".to_owned(),
-            Some(ref hash) if hash.as_slice() == "" => "".to_owned(),
+            Some(ref hash) if hash.is_empty() => "".to_owned(),
             Some(ref hash) => format!("#{}", hash)
         })
     }

components/script/dom/urlsearchparams.rs

@@ -116,10 +116,9 @@ pub trait URLSearchParamsHelpers {
 impl URLSearchParamsHelpers for URLSearchParams {
     fn serialize(&self, encoding: Option<EncodingRef>) -> Vec<u8> {
         // https://url.spec.whatwg.org/#concept-urlencoded-serializer
-        fn serialize_string(value: &DOMString, encoding: EncodingRef) -> Vec<u8> {
+        fn serialize_string(value: &str, encoding: EncodingRef) -> Vec<u8> {
             // https://url.spec.whatwg.org/#concept-urlencoded-byte-serializer
 
-            let value = value.as_slice();
             // XXXManishearth should this be a strict encoding? Can unwrap()ing the result fail?
             let value = encoding.encode(value, EncoderTrap::Replace).unwrap();
 

components/script/dom/window.rs

@@ -253,7 +253,7 @@ pub fn base64_btoa(input: DOMString) -> Fallible<DOMString> {
 
         // "and then must apply the base64 algorithm to that sequence of
         //  octets, and return the result. [RFC4648]"
-        Ok(octets.as_slice().to_base64(STANDARD))
+        Ok(octets.to_base64(STANDARD))
     }
 }
 
@@ -269,7 +269,7 @@ pub fn base64_atob(input: DOMString) -> Fallible<DOMString> {
     let without_spaces = input.chars()
         .filter(|&c| ! is_html_space(c))
         .collect::<String>();
-    let mut input = without_spaces.as_slice();
+    let mut input = &*without_spaces;
 
     // "If the length of input divides by 4 leaving no remainder, then:
     //  if input ends with one or two U+003D EQUALS SIGN (=) characters,
@@ -520,7 +520,7 @@ impl<'a, T: Reflectable> ScriptHelpers for JSRef<'a, T> {
         let this = self.reflector().get_jsobject();
         let cx = global_object_for_js_object(this).root().r().get_cx();
         let global = global_object_for_js_object(this).root().r().reflector().get_jsobject();
-        let code: Vec<u16> = code.as_slice().utf16_units().collect();
+        let code: Vec<u16> = code.utf16_units().collect();
         let mut rval = UndefinedValue();
         let filename = CString::new(filename).unwrap();
 

components/script/dom/worker.rs

@@ -63,8 +63,7 @@ impl Worker {
     // https://www.whatwg.org/html/#dom-worker
     pub fn Constructor(global: GlobalRef, script_url: DOMString) -> Fallible<Temporary<Worker>> {
         // Step 2-4.
-        let worker_url = match UrlParser::new().base_url(&global.get_url())
+        let worker_url = match UrlParser::new().base_url(&global.get_url()).parse(&script_url) {
-                .parse(script_url.as_slice()) {
             Ok(url) => url,
             Err(_) => return Err(Syntax),
         };

components/script/dom/workerglobalscope.rs

@@ -122,7 +122,7 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
         let mut urls = Vec::with_capacity(url_strings.len());
         for url in url_strings.into_iter() {
             let url = UrlParser::new().base_url(&self.worker_url)
-                                      .parse(url.as_slice());
+                                      .parse(&url);
             match url {
                 Ok(url) => urls.push(url),
                 Err(_) => return Err(Syntax),

components/script/dom/xmlhttprequest.rs

@@ -252,7 +252,7 @@ impl XMLHttpRequest {
             }
 
             fn data_available(&self, payload: Vec<u8>) {
-                self.buf.borrow_mut().push_all(payload.as_slice());
+                self.buf.borrow_mut().push_all(&payload);
                 let xhr = self.xhr.to_temporary().root();
                 xhr.r().process_data_available(self.gen_id, self.buf.borrow().clone());
             }
@@ -297,7 +297,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
             // since methods like "patch" or "PaTcH" will be considered extension methods
             // despite the there being a rust-http method variant for them
             let upper = s.to_ascii_uppercase();
-            match upper.as_slice() {
+            match &*upper {
                 "DELETE" | "GET" | "HEAD" | "OPTIONS" |
                 "POST" | "PUT" | "CONNECT" | "TRACE" |
                 "TRACK" => upper.parse().ok(),
@@ -308,7 +308,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
         match maybe_method {
             // Step 4
             Some(Method::Connect) | Some(Method::Trace) => Err(Security),
-            Some(Method::Extension(ref t)) if t.as_slice() == "TRACK" => Err(Security),
+            Some(Method::Extension(ref t)) if &**t == "TRACK" => Err(Security),
             Some(parsed_method) => {
                 // Step 3
                 if !method.is_token() {
@@ -319,7 +319,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
 
                 // Step 6
                 let base = self.global.root().r().get_url();
-                let parsed_url = match UrlParser::new().base_url(&base).parse(url.as_slice()) {
+                let parsed_url = match UrlParser::new().base_url(&base).parse(&url) {
                     Ok(parsed) => parsed,
                     Err(_) => return Err(Syntax) // Step 7
                 };
@@ -562,14 +562,14 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
         match cors_request {
             Ok(None) => {
                 let mut buf = String::new();
-                buf.push_str(referer_url.scheme.as_slice());
+                buf.push_str(&referer_url.scheme);
-                buf.push_str("://".as_slice());
+                buf.push_str("://");
-                referer_url.serialize_host().map(|ref h| buf.push_str(h.as_slice()));
+                referer_url.serialize_host().map(|ref h| buf.push_str(h));
                 referer_url.port().as_ref().map(|&p| {
-                    buf.push_str(":".as_slice());
+                    buf.push_str(":");
-                    buf.push_str(p.to_string().as_slice());
+                    buf.push_str(&p.to_string());
                 });
-                referer_url.serialize_path().map(|ref h| buf.push_str(h.as_slice()));
+                referer_url.serialize_path().map(|ref h| buf.push_str(h));
                 self.request_headers.borrow_mut().set_raw("Referer".to_owned(), vec![buf.into_bytes()]);
             },
             Ok(Some(ref req)) => self.insert_trusted_header("origin".to_owned(),
@@ -678,7 +678,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
             _ if self.ready_state.get() != XMLHttpRequestState::Done => NullValue(),
             Json => {
                 let decoded = UTF_8.decode(self.response.borrow().as_slice(), DecoderTrap::Replace).unwrap().to_owned();
-                let decoded: Vec<u16> = decoded.as_slice().utf16_units().collect();
+                let decoded: Vec<u16> = decoded.utf16_units().collect();
                 let mut vp = UndefinedValue();
                 unsafe {
                     if JS_ParseJSON(cx, decoded.as_ptr(), decoded.len() as u32, &mut vp) == 0 {
@@ -1015,7 +1015,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
             Some(&ContentType(mime::Mime(_, _, ref params))) => {
                 for &(ref name, ref value) in params.iter() {
                     if name == &mime::Attr::Charset {
-                        encoding = encoding_from_whatwg_label(value.to_string().as_slice()).unwrap_or(encoding);
+                        encoding = encoding_from_whatwg_label(&value.to_string()).unwrap_or(encoding);
                     }
                 }
             },
@@ -1127,7 +1127,7 @@ impl Extractable for SendParam {
         // https://fetch.spec.whatwg.org/#concept-fetchbodyinit-extract
         let encoding = UTF_8 as EncodingRef;
         match *self {
-            eString(ref s) => encoding.encode(s.as_slice(), EncoderTrap::Replace).unwrap(),
+            eString(ref s) => encoding.encode(s, EncoderTrap::Replace).unwrap(),
             eURLSearchParams(ref usp) => usp.root().r().serialize(None) // Default encoding is UTF8
         }
     }

components/script/parse/html.rs

@@ -244,7 +244,7 @@ impl<'a> Serializable for JSRef<'a, Node> {
 
             (IncludeNode, NodeTypeId::DocumentType) => {
                 let doctype: JSRef<DocumentType> = DocumentTypeCast::to_ref(node).unwrap();
-                serializer.write_doctype(doctype.name().as_slice())
+                serializer.write_doctype(&doctype.name())
             },
 
             (IncludeNode, NodeTypeId::Text) => {
@@ -290,7 +290,7 @@ pub fn parse_html(document: JSRef<Document>,
             match msg {
                 ProgressMsg::Payload(data) => {
                     // FIXME: use Vec<u8> (html5ever #34)
-                    let data = UTF_8.decode(data.as_slice(), DecoderTrap::Replace).unwrap();
+                    let data = UTF_8.decode(&data, DecoderTrap::Replace).unwrap();
                     parser.parse_chunk(data);
                 }
                 ProgressMsg::Done(Err(err)) => {

components/script/textinput.rs

@@ -291,7 +291,7 @@ impl TextInput {
             }
             return Selection::NotSelected
         }
-        match event.Key().as_slice() {
+        match &*event.Key() {
            "a" if is_control_key(event) => {
                 self.select_all();
                 KeyReaction::Nothing
@@ -304,7 +304,7 @@ impl TextInput {
                     contents = Some(rx.recv().unwrap());
                 }
                 if let Some(contents) = contents {
-                    self.insert_string(contents.as_slice());
+                    self.insert_string(&contents);
                 }
                 KeyReaction::DispatchInput
             },

components/script/timers.rs

@@ -238,7 +238,7 @@ impl TimerManager {
                 let _ = function.Call_(this, data.args, Report);
             }
             TimerCallback::StringTimerCallback(code_str) => {
-                this.evaluate_js_on_global_with_result(code_str.as_slice());
+                this.evaluate_js_on_global_with_result(&code_str);
             }
         };
 

ports/gonk/src/input.rs

@@ -139,7 +139,7 @@ fn read_input_device(device_path: &Path,
     // XXX: Need to use the real dimensions of the screen
     let screen_dist = dist(0, 480, 854, 0);
     loop {
-        let read = match device.read(buf.as_mut_slice()) {
+        let read = match device.read(&mut buf) {
             Ok(count) => {
                 assert!(count % size_of::<linux_input_event>() == 0,
                         "Unexpected input device read length!");