Merge pull request #3438 from servo/rustup

Upgrade Rust

26 files changed, 220 insertions, 223 deletions

diff --git a/components/script/cors.rs b/components/script/cors.rs
index 3a3fd98ee90..a4702eb21de 100644
--- a/components/script/cors.rs
+++ b/components/script/cors.rs
@@ -16,9 +16,9 @@ use std::str::StrSlice;
 use time;
 use time::{now, Timespec};
 
-use ResponseHeaderCollection = http::headers::response::HeaderCollection;
-use RequestHeaderCollection = http::headers::request::HeaderCollection;
-use RequestHeader = http::headers::request::Header;
+use http::headers::response::HeaderCollection as ResponseHeaderCollection;
+use http::headers::request::HeaderCollection as RequestHeaderCollection;
+use http::headers::request::Header as RequestHeader;
 
 use http::client::{RequestWriter, NetworkStream};
 use http::headers::{HeaderConvertible, HeaderEnum, HeaderValueByteIterator};
@@ -146,7 +146,7 @@ impl CORSRequest {
         };
 
         let host = writer.headers.host.clone();
-        writer.headers = box preflight.headers.clone();
+        writer.headers = preflight.headers.clone();
         writer.headers.host = host;
         let response = match writer.read_response() {
             Ok(r) => r,
@@ -158,19 +158,19 @@ impl CORSRequest {
          200 .. 299 => {}
          _ => return error
         }
-        cors_response.headers = *response.headers.clone();
+        cors_response.headers = response.headers.clone();
         // Substeps 1-3 (parsing rules: http://fetch.spec.whatwg.org/#http-new-header-syntax)
         fn find_header(headers: &ResponseHeaderCollection, name: &str) -> Option<String> {
             headers.iter().find(|h| h.header_name().as_slice()
                                                    .eq_ignore_ascii_case(name))
                                     .map(|h| h.header_value())
         }
-        let methods_string = match find_header(&*response.headers, "Access-Control-Allow-Methods") {
+        let methods_string = match find_header(&response.headers, "Access-Control-Allow-Methods") {
             Some(s) => s,
             _ => return error
         };
         let methods = methods_string.as_slice().split(',');
-        let headers_string = match find_header(&*response.headers, "Access-Control-Allow-Headers") {
+        let headers_string = match find_header(&response.headers, "Access-Control-Allow-Headers") {
             Some(s) => s,
             _ => return error
         };
@@ -197,7 +197,7 @@ impl CORSRequest {
             }
         }
         // Substep 7, 8
-        let max_age: uint = find_header(&*response.headers, "Access-Control-Max-Age")
+        let max_age: uint = find_header(&response.headers, "Access-Control-Max-Age")
                                 .and_then(|h| FromStr::from_str(h.as_slice())).unwrap_or(0);
         // Substep 9: Impose restrictions on max-age, if any (unimplemented)
         // Substeps 10-12: Add a cache (partially implemented, XXXManishearth)
@@ -315,7 +315,7 @@ impl CORSCache {
     #[allow(dead_code)]
     fn clear (&mut self, request: &CORSRequest) {
         let CORSCache(buf) = self.clone();
-        let new_buf: Vec<CORSCacheEntry> = buf.move_iter().filter(|e| e.origin == request.origin && request.destination == e.url).collect();
+        let new_buf: Vec<CORSCacheEntry> = buf.into_iter().filter(|e| e.origin == request.origin && request.destination == e.url).collect();
         *self = CORSCache(new_buf);
     }
 
@@ -323,7 +323,7 @@ impl CORSCache {
     fn cleanup(&mut self) {
         let CORSCache(buf) = self.clone();
         let now = time::now().to_timespec();
-        let new_buf: Vec<CORSCacheEntry> = buf.move_iter().filter(|e| now.sec > e.created.sec + e.max_age as i64).collect();
+        let new_buf: Vec<CORSCacheEntry> = buf.into_iter().filter(|e| now.sec > e.created.sec + e.max_age as i64).collect();
         *self = CORSCache(new_buf);
     }
 
@@ -332,7 +332,7 @@ impl CORSCache {
         self.cleanup();
         let CORSCache(ref mut buf) = *self;
         // Credentials are not yet implemented here
-        let entry = buf.mut_iter().find(|e| e.origin.scheme == request.origin.scheme &&
+        let entry = buf.iter_mut().find(|e| e.origin.scheme == request.origin.scheme &&
                             e.origin.host() == request.origin.host() &&
                             e.origin.port() == request.origin.port() &&
                             e.url == request.destination &&
@@ -353,7 +353,7 @@ impl CORSCache {
         self.cleanup();
         let CORSCache(ref mut buf) = *self;
         // Credentials are not yet implemented here
-        let entry = buf.mut_iter().find(|e| e.origin.scheme == request.origin.scheme &&
+        let entry = buf.iter_mut().find(|e| e.origin.scheme == request.origin.scheme &&
                             e.origin.host() == request.origin.host() &&
                             e.origin.port() == request.origin.port() &&
                             e.url == request.destination &&
diff --git a/components/script/dom/bindings/callback.rs b/components/script/dom/bindings/callback.rs
index b4394647bbd..5c1f4c771cb 100644
--- a/components/script/dom/bindings/callback.rs
+++ b/components/script/dom/bindings/callback.rs
@@ -121,7 +121,7 @@ pub fn WrapCallThisObject<T: Reflectable>(cx: *mut JSContext,
 
     unsafe {
         if JS_WrapObject(cx, &mut obj) == 0 {
-            return ptr::mut_null();
+            return ptr::null_mut();
         }
     }
 
diff --git a/components/script/dom/bindings/codegen/CodegenRust.py b/components/script/dom/bindings/codegen/CodegenRust.py
index 8ec5f24ccdd..383595248c3 100644
--- a/components/script/dom/bindings/codegen/CodegenRust.py
+++ b/components/script/dom/bindings/codegen/CodegenRust.py
@@ -1757,6 +1757,7 @@ class CGAbstractMethod(CGThing):
             decorators.append('#[inline(always)]')
 
         if self.extern:
+            decorators.append('unsafe')
             decorators.append('extern')
 
         if self.pub:
@@ -1797,7 +1798,7 @@ let obj = with_compartment(aCx, proto, || {
   NewProxyObject(aCx, handler,
                  &private,
                  proto, %s,
-                 ptr::mut_null(), ptr::mut_null())
+                 ptr::null_mut(), ptr::null_mut())
 });
 assert!(obj.is_not_null());
 
@@ -3665,7 +3666,7 @@ if expando.is_not_null() {
   }
 }
 """ + namedGet + """
-(*desc).obj = ptr::mut_null();
+(*desc).obj = ptr::null_mut();
 return true;"""
 
     def definition_body(self):
@@ -4302,11 +4303,11 @@ class CGDictionary(CGThing):
         return string.Template(
             "impl<'a, 'b> ${selfName}<'a, 'b> {\n"
             "  pub fn empty() -> ${selfName}<'a, 'b> {\n"
-            "    ${selfName}::new(ptr::mut_null(), NullValue()).unwrap()\n"
+            "    ${selfName}::new(ptr::null_mut(), NullValue()).unwrap()\n"
             "  }\n"
             "  pub fn new(cx: *mut JSContext, val: JSVal) -> Result<${selfName}<'a, 'b>, ()> {\n"
             "    let object = if val.is_null_or_undefined() {\n"
-            "        ptr::mut_null()\n"
+            "        ptr::null_mut()\n"
             "    } else if val.is_object() {\n"
             "        val.to_object()\n"
             "    } else {\n"
@@ -4538,7 +4539,6 @@ class CGBindingRoot(CGThing):
             'dom::bindings::conversions::{Default, Empty}',
             'dom::bindings::codegen::*',
             'dom::bindings::codegen::Bindings::*',
-            'dom::bindings::codegen::RegisterBindings',
             'dom::bindings::codegen::UnionTypes::*',
             'dom::bindings::error::{FailureUnknown, Fallible, Error, ErrorResult}',
             'dom::bindings::error::throw_dom_exception',
@@ -4914,7 +4914,7 @@ class CGCallback(CGClass):
         # the private method.
         argnames = [arg.name for arg in args]
         argnamesWithThis = ["s.GetContext()", "thisObjJS"] + argnames
-        argnamesWithoutThis = ["s.GetContext()", "ptr::mut_null()"] + argnames
+        argnamesWithoutThis = ["s.GetContext()", "ptr::null_mut()"] + argnames
         # Now that we've recorded the argnames for our call to our private
         # method, insert our optional argument for deciding whether the
         # CallSetup should re-throw exceptions on aRv.
@@ -5477,12 +5477,12 @@ class GlobalGenRoots():
   }
 
   #[inline(always)]
-  fn from_ref<'a, T: ${fromBound}>(derived: JSRef<'a, T>) -> JSRef<'a, Self> {
+  fn from_ref<'a, T: ${fromBound}+Reflectable>(derived: JSRef<'a, T>) -> JSRef<'a, Self> {
     unsafe { derived.transmute() }
   }
 
   #[inline(always)]
-  fn from_borrowed_ref<'a, 'b, T: ${fromBound}>(derived: &'a JSRef<'b, T>) -> &'a JSRef<'b, Self> {
+  fn from_borrowed_ref<'a, 'b, T: ${fromBound}+Reflectable>(derived: &'a JSRef<'b, T>) -> &'a JSRef<'b, Self> {
     unsafe { derived.transmute_borrowed() }
   }
 
diff --git a/components/script/dom/bindings/error.rs b/components/script/dom/bindings/error.rs
index cb39e4f0755..e2e06d8205a 100644
--- a/components/script/dom/bindings/error.rs
+++ b/components/script/dom/bindings/error.rs
@@ -97,7 +97,7 @@ static ERROR_FORMAT_STRING: JSErrorFormatString = JSErrorFormatString {
 };
 
 /// Callback used to throw `TypeError`s.
-extern fn get_error_message(_user_ref: *mut libc::c_void,
+unsafe extern fn get_error_message(_user_ref: *mut libc::c_void,
                             _locale: *const libc::c_char,
                             error_number: libc::c_uint) -> *const JSErrorFormatString
 {
@@ -109,6 +109,6 @@ extern fn get_error_message(_user_ref: *mut libc::c_void,
 pub fn throw_type_error(cx: *mut JSContext, error: &str) {
     let error = error.to_c_str();
     unsafe {
-        JS_ReportErrorNumber(cx, Some(get_error_message), ptr::mut_null(), 0, error.as_ptr());
+        JS_ReportErrorNumber(cx, Some(get_error_message), ptr::null_mut(), 0, error.as_ptr());
     }
 }
diff --git a/components/script/dom/bindings/js.rs b/components/script/dom/bindings/js.rs
index 5395db760fd..3fff9445c3c 100644
--- a/components/script/dom/bindings/js.rs
+++ b/components/script/dom/bindings/js.rs
@@ -255,7 +255,7 @@ impl<T> Assignable<T> for JS<T> {
     }
 }
 
-impl<'a, T> Assignable<T> for JSRef<'a, T> {
+impl<'a, T: Reflectable> Assignable<T> for JSRef<'a, T> {
     unsafe fn get_js(&self) -> JS<T> {
         self.unrooted()
     }
diff --git a/components/script/dom/bindings/proxyhandler.rs b/components/script/dom/bindings/proxyhandler.rs
index f2c1486280d..3c26206c373 100644
--- a/components/script/dom/bindings/proxyhandler.rs
+++ b/components/script/dom/bindings/proxyhandler.rs
@@ -26,11 +26,10 @@ use std::mem::size_of;
 
 static JSPROXYSLOT_EXPANDO: u32 = 0;
 
-pub extern fn getPropertyDescriptor(cx: *mut JSContext, proxy: *mut JSObject,
-                                    id: jsid, set: bool,
-                                    desc: *mut JSPropertyDescriptor)
-                                    -> bool {
-  unsafe {
+pub unsafe extern fn getPropertyDescriptor(cx: *mut JSContext, proxy: *mut JSObject,
+                                           id: jsid, set: bool,
+                                           desc: *mut JSPropertyDescriptor)
+                                           -> bool {
     let handler = GetProxyHandler(proxy);
     if !InvokeGetOwnPropertyDescriptor(handler, cx, proxy, id, set, desc) {
         return false;
@@ -42,55 +41,50 @@ pub extern fn getPropertyDescriptor(cx: *mut JSContext, proxy: *mut JSObject,
     //let proto = JS_GetPrototype(proxy);
     let proto = GetObjectProto(proxy);
     if proto.is_null() {
-        (*desc).obj = ptr::mut_null();
+        (*desc).obj = ptr::null_mut();
         return true;
     }
 
     JS_GetPropertyDescriptorById(cx, proto, id, JSRESOLVE_QUALIFIED, desc) != 0
-  }
 }
 
-pub fn defineProperty_(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
-                       desc: *mut JSPropertyDescriptor) -> bool {
+pub unsafe fn defineProperty_(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
+                              desc: *mut JSPropertyDescriptor) -> bool {
     static JSMSG_GETTER_ONLY: libc::c_uint = 160;
 
-    unsafe {
-        //FIXME: Workaround for https://github.com/mozilla/rust/issues/13385
-        let setter: *const libc::c_void = mem::transmute((*desc).setter);
-        let setter_stub: *const libc::c_void = mem::transmute(JS_StrictPropertyStub);
-        if ((*desc).attrs & JSPROP_GETTER) != 0 && setter == setter_stub {
-            return JS_ReportErrorFlagsAndNumber(cx,
-                                                JSREPORT_WARNING | JSREPORT_STRICT |
-                                                JSREPORT_STRICT_MODE_ERROR,
-                                                Some(RUST_js_GetErrorMessage), ptr::mut_null(),
-                                                JSMSG_GETTER_ONLY) != 0;
-        }
-
-        let expando = EnsureExpandoObject(cx, proxy);
-        if expando.is_null() {
-            return false;
-        }
+    //FIXME: Workaround for https://github.com/mozilla/rust/issues/13385
+    let setter: *const libc::c_void = mem::transmute((*desc).setter);
+    let setter_stub: *const libc::c_void = mem::transmute(JS_StrictPropertyStub);
+    if ((*desc).attrs & JSPROP_GETTER) != 0 && setter == setter_stub {
+        return JS_ReportErrorFlagsAndNumber(cx,
+                                            JSREPORT_WARNING | JSREPORT_STRICT |
+                                            JSREPORT_STRICT_MODE_ERROR,
+                                            Some(RUST_js_GetErrorMessage), ptr::null_mut(),
+                                            JSMSG_GETTER_ONLY) != 0;
+    }
 
-        return JS_DefinePropertyById(cx, expando, id, (*desc).value, (*desc).getter,
-                                     (*desc).setter, (*desc).attrs) != 0;
+    let expando = EnsureExpandoObject(cx, proxy);
+    if expando.is_null() {
+        return false;
     }
+
+    return JS_DefinePropertyById(cx, expando, id, (*desc).value, (*desc).getter,
+                                 (*desc).setter, (*desc).attrs) != 0;
 }
 
-pub extern fn defineProperty(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
-                             desc: *mut JSPropertyDescriptor) -> bool {
+pub unsafe extern fn defineProperty(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
+                                    desc: *mut JSPropertyDescriptor) -> bool {
     defineProperty_(cx, proxy, id, desc)
 }
 
-pub extern fn delete_(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
-                      bp: *mut bool) -> bool {
-    unsafe {
-        let expando = EnsureExpandoObject(cx, proxy);
-        if expando.is_null() {
-            return false;
-        }
-
-        return delete_property_by_id(cx, expando, id, &mut *bp);
+pub unsafe extern fn delete_(cx: *mut JSContext, proxy: *mut JSObject, id: jsid,
+                             bp: *mut bool) -> bool {
+    let expando = EnsureExpandoObject(cx, proxy);
+    if expando.is_null() {
+        return false;
     }
+
+    return delete_property_by_id(cx, expando, id, &mut *bp);
 }
 
 pub fn _obj_toString(cx: *mut JSContext, className: *const libc::c_char) -> *mut JSString {
@@ -99,7 +93,7 @@ pub fn _obj_toString(cx: *mut JSContext, className: *const libc::c_char) -> *mut
     let nchars = "[object ]".len() + name.len();
     let chars: *mut jschar = JS_malloc(cx, (nchars + 1) as libc::size_t * (size_of::<jschar>() as libc::size_t)) as *mut jschar;
     if chars.is_null() {
-        return ptr::mut_null();
+        return ptr::null_mut();
     }
 
     let result = format!("[object {}]", name);
@@ -121,7 +115,7 @@ pub fn GetExpandoObject(obj: *mut JSObject) -> *mut JSObject {
         assert!(is_dom_proxy(obj));
         let val = GetProxyExtra(obj, JSPROXYSLOT_EXPANDO);
         if val.is_undefined() {
-            ptr::mut_null()
+            ptr::null_mut()
         } else {
             val.to_object()
         }
@@ -133,11 +127,11 @@ pub fn EnsureExpandoObject(cx: *mut JSContext, obj: *mut JSObject) -> *mut JSObj
         assert!(is_dom_proxy(obj));
         let mut expando = GetExpandoObject(obj);
         if expando.is_null() {
-            expando = JS_NewObjectWithGivenProto(cx, ptr::mut_null(),
-                                                 ptr::mut_null(),
+            expando = JS_NewObjectWithGivenProto(cx, ptr::null_mut(),
+                                                 ptr::null_mut(),
                                                  GetObjectParent(obj));
             if expando.is_null() {
-                return ptr::mut_null();
+                return ptr::null_mut();
             }
 
             SetProxyExtra(obj, JSPROXYSLOT_EXPANDO, ObjectValue(&*expando));
diff --git a/components/script/dom/bindings/utils.rs b/components/script/dom/bindings/utils.rs
index 0f6ab2098fe..a923371ae8e 100644
--- a/components/script/dom/bindings/utils.rs
+++ b/components/script/dom/bindings/utils.rs
@@ -129,7 +129,7 @@ pub fn unwrap_jsmanaged<T: Reflectable>(mut obj: *mut JSObject,
         let dom_class = get_dom_class(obj).or_else(|_| {
             if IsWrapper(obj) == 1 {
                 debug!("found wrapper");
-                obj = UnwrapObject(obj, /* stopAtOuter = */ 0, ptr::mut_null());
+                obj = UnwrapObject(obj, /* stopAtOuter = */ 0, ptr::null_mut());
                 if obj.is_null() {
                     debug!("unwrapping security wrapper failed");
                     Err(())
@@ -421,7 +421,7 @@ fn CreateInterfacePrototypeObject(cx: *mut JSContext, global: *mut JSObject,
 
 /// A throwing constructor, for those interfaces that have neither
 /// `NoInterfaceObject` nor `Constructor`.
-pub extern fn ThrowingConstructor(cx: *mut JSContext, _argc: c_uint, _vp: *mut JSVal) -> JSBool {
+pub unsafe extern fn ThrowingConstructor(cx: *mut JSContext, _argc: c_uint, _vp: *mut JSVal) -> JSBool {
     throw_type_error(cx, "Illegal constructor.");
     return 0;
 }
@@ -488,7 +488,7 @@ impl Reflector {
     /// Create an uninitialized `Reflector`.
     pub fn new() -> Reflector {
         Reflector {
-            object: Cell::new(ptr::mut_null()),
+            object: Cell::new(ptr::null_mut()),
         }
     }
 }
@@ -613,7 +613,7 @@ pub fn get_dictionary_property(cx: *mut JSContext,
 pub fn HasPropertyOnPrototype(cx: *mut JSContext, proxy: *mut JSObject, id: jsid) -> bool {
     //  MOZ_ASSERT(js::IsProxy(proxy) && js::GetProxyHandler(proxy) == handler);
     let mut found = false;
-    return !GetPropertyOnPrototype(cx, proxy, id, &mut found, ptr::mut_null()) || found;
+    return !GetPropertyOnPrototype(cx, proxy, id, &mut found, ptr::null_mut()) || found;
 }
 
 /// Returns whether `obj` can be converted to a callback interface per IDL.
@@ -626,9 +626,9 @@ pub fn IsConvertibleToCallbackInterface(cx: *mut JSContext, obj: *mut JSObject)
 /// Create a DOM global object with the given class.
 pub fn CreateDOMGlobal(cx: *mut JSContext, class: *const JSClass) -> *mut JSObject {
     unsafe {
-        let obj = JS_NewGlobalObject(cx, class, ptr::mut_null());
+        let obj = JS_NewGlobalObject(cx, class, ptr::null_mut());
         if obj.is_null() {
-            return ptr::mut_null();
+            return ptr::null_mut();
         }
         with_compartment(cx, obj, || {
             JS_InitStandardClasses(cx, obj);
@@ -639,18 +639,14 @@ pub fn CreateDOMGlobal(cx: *mut JSContext, class: *const JSClass) -> *mut JSObje
 }
 
 /// Callback to outerize windows when wrapping.
-pub extern fn wrap_for_same_compartment(cx: *mut JSContext, obj: *mut JSObject) -> *mut JSObject {
-    unsafe {
-        JS_ObjectToOuterObject(cx, obj)
-    }
+pub unsafe extern fn wrap_for_same_compartment(cx: *mut JSContext, obj: *mut JSObject) -> *mut JSObject {
+    JS_ObjectToOuterObject(cx, obj)
 }
 
 /// Callback to outerize windows before wrapping.
-pub extern fn pre_wrap(cx: *mut JSContext, _scope: *mut JSObject,
+pub unsafe extern fn pre_wrap(cx: *mut JSContext, _scope: *mut JSObject,
                        obj: *mut JSObject, _flags: c_uint) -> *mut JSObject {
-    unsafe {
-        JS_ObjectToOuterObject(cx, obj)
-    }
+    JS_ObjectToOuterObject(cx, obj)
 }
 
 /// Callback to outerize windows.
@@ -664,7 +660,7 @@ pub extern fn outerize_global(_cx: *mut JSContext, obj: JSHandleObject) -> *mut
                              IDLInterface::get_prototype_depth(None::<window::Window>))
             .unwrap()
             .root();
-        win.deref().browser_context.deref().borrow().get_ref().window_proxy()
+        win.deref().browser_context.deref().borrow().as_ref().unwrap().window_proxy()
     }
 }
 
@@ -675,12 +671,12 @@ pub fn global_object_for_js_object(obj: *mut JSObject) -> GlobalField {
         let global = GetGlobalForObjectCrossCompartment(obj);
         let clasp = JS_GetClass(global);
         assert!(((*clasp).flags & (JSCLASS_IS_DOMJSCLASS | JSCLASS_IS_GLOBAL)) != 0);
-        match FromJSValConvertible::from_jsval(ptr::mut_null(), ObjectOrNullValue(global), ()) {
+        match FromJSValConvertible::from_jsval(ptr::null_mut(), ObjectOrNullValue(global), ()) {
             Ok(window) => return WindowField(window),
             Err(_) => (),
         }
 
-        match FromJSValConvertible::from_jsval(ptr::mut_null(), ObjectOrNullValue(global), ()) {
+        match FromJSValConvertible::from_jsval(ptr::null_mut(), ObjectOrNullValue(global), ()) {
             Ok(worker) => return WorkerField(worker),
             Err(_) => (),
         }
diff --git a/components/script/dom/browsercontext.rs b/components/script/dom/browsercontext.rs
index fee00301d55..c9ac5e2f040 100644
--- a/components/script/dom/browsercontext.rs
+++ b/components/script/dom/browsercontext.rs
@@ -28,7 +28,7 @@ impl BrowserContext {
         let mut context = BrowserContext {
             history: vec!(SessionHistoryEntry::new(document)),
             active_index: 0,
-            window_proxy: Traceable::new(ptr::mut_null()),
+            window_proxy: Traceable::new(ptr::null_mut()),
         };
         context.create_window_proxy();
         context
@@ -53,11 +53,11 @@ impl BrowserContext {
         let page = win.deref().page();
         let js_info = page.js_info();
 
-        let handler = js_info.get_ref().dom_static.windowproxy_handler;
+        let handler = js_info.as_ref().unwrap().dom_static.windowproxy_handler;
         assert!(handler.deref().is_not_null());
 
         let parent = win.deref().reflector().get_jsobject();
-        let cx = js_info.get_ref().js_context.deref().deref().ptr;
+        let cx = js_info.as_ref().unwrap().js_context.deref().deref().ptr;
         let wrapper = with_compartment(cx, parent, || unsafe {
             WrapperNew(cx, parent, *handler.deref())
         });
diff --git a/components/script/dom/dedicatedworkerglobalscope.rs b/components/script/dom/dedicatedworkerglobalscope.rs
index 4050e157dad..8842aee2f37 100644
--- a/components/script/dom/dedicatedworkerglobalscope.rs
+++ b/components/script/dom/dedicatedworkerglobalscope.rs
@@ -127,7 +127,7 @@ impl DedicatedWorkerGlobalScope {
                             assert!(JS_ReadStructuredClone(
                                 js_context.ptr, data as *const u64, nbytes,
                                 JS_STRUCTURED_CLONE_VERSION, &mut message,
-                                ptr::null(), ptr::mut_null()) != 0);
+                                ptr::null(), ptr::null_mut()) != 0);
                         }
 
                         MessageEvent::dispatch_jsval(target, &Worker(scope), message);
@@ -152,11 +152,11 @@ impl DedicatedWorkerGlobalScope {
 
 impl<'a> DedicatedWorkerGlobalScopeMethods for JSRef<'a, DedicatedWorkerGlobalScope> {
     fn PostMessage(self, cx: *mut JSContext, message: JSVal) {
-        let mut data = ptr::mut_null();
+        let mut data = ptr::null_mut();
         let mut nbytes = 0;
         unsafe {
             assert!(JS_WriteStructuredClone(cx, message, &mut data, &mut nbytes,
-                                            ptr::null(), ptr::mut_null()) != 0);
+                                            ptr::null(), ptr::null_mut()) != 0);
         }
 
         let ScriptChan(ref sender) = self.parent_sender;
diff --git a/components/script/dom/document.rs b/components/script/dom/document.rs
index b6971f5dd14..265131f00f0 100644
--- a/components/script/dom/document.rs
+++ b/components/script/dom/document.rs
@@ -356,12 +356,14 @@ impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
     }
 
     fn get_html_element(self) -> Option<Temporary<HTMLHtmlElement>> {
-        self.GetDocumentElement().root().filtered(|root| {
-            let root: JSRef<Node> = NodeCast::from_ref(**root);
-            root.type_id() == ElementNodeTypeId(HTMLHtmlElementTypeId)
-        }).map(|elem| {
-            Temporary::from_rooted(HTMLHtmlElementCast::to_ref(*elem).unwrap())
-        })
+        match self.GetDocumentElement().root() {
+            Some(ref root) if {
+                let root: JSRef<Node> = NodeCast::from_ref(**root);
+                root.type_id() == ElementNodeTypeId(HTMLHtmlElementTypeId)
+            } => Some(Temporary::from_rooted(HTMLHtmlElementCast::to_ref(**root).unwrap())),
+
+            _ => None,
+        }
     }
 }
 
@@ -371,7 +373,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
         if self.implementation.get().is_none() {
             self.implementation.assign(Some(DOMImplementation::new(self)));
         }
-        Temporary::new(self.implementation.get().get_ref().clone())
+        Temporary::new(self.implementation.get().as_ref().unwrap().clone())
     }
 
     // http://dom.spec.whatwg.org/#dom-document-url
@@ -751,7 +753,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let filter = box ImagesFilter;
             self.images.assign(Some(HTMLCollection::create(*window, root, filter)));
         }
-        Temporary::new(self.images.get().get_ref().clone())
+        Temporary::new(self.images.get().as_ref().unwrap().clone())
     }
 
     fn Embeds(self) -> Temporary<HTMLCollection> {
@@ -761,7 +763,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let filter = box EmbedsFilter;
             self.embeds.assign(Some(HTMLCollection::create(*window, root, filter)));
         }
-        Temporary::new(self.embeds.get().get_ref().clone())
+        Temporary::new(self.embeds.get().as_ref().unwrap().clone())
     }
 
     fn Plugins(self) -> Temporary<HTMLCollection> {
@@ -775,7 +777,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let filter = box LinksFilter;
             self.links.assign(Some(HTMLCollection::create(*window, root, filter)));
         }
-        Temporary::new(self.links.get().get_ref().clone())
+        Temporary::new(self.links.get().as_ref().unwrap().clone())
     }
 
     fn Forms(self) -> Temporary<HTMLCollection> {
@@ -785,7 +787,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let filter = box FormsFilter;
             self.forms.assign(Some(HTMLCollection::create(*window, root, filter)));
         }
-        Temporary::new(self.forms.get().get_ref().clone())
+        Temporary::new(self.forms.get().as_ref().unwrap().clone())
     }
 
     fn Scripts(self) -> Temporary<HTMLCollection> {
@@ -795,7 +797,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let filter = box ScriptsFilter;
             self.scripts.assign(Some(HTMLCollection::create(*window, root, filter)));
         }
-        Temporary::new(self.scripts.get().get_ref().clone())
+        Temporary::new(self.scripts.get().as_ref().unwrap().clone())
     }
 
     fn Anchors(self) -> Temporary<HTMLCollection> {
@@ -805,7 +807,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let filter = box AnchorsFilter;
             self.anchors.assign(Some(HTMLCollection::create(*window, root, filter)));
         }
-        Temporary::new(self.anchors.get().get_ref().clone())
+        Temporary::new(self.anchors.get().as_ref().unwrap().clone())
     }
 
     fn Applets(self) -> Temporary<HTMLCollection> {
@@ -816,7 +818,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             let filter = box AppletsFilter;
             self.applets.assign(Some(HTMLCollection::create(*window, root, filter)));
         }
-        Temporary::new(self.applets.get().get_ref().clone())
+        Temporary::new(self.applets.get().as_ref().unwrap().clone())
     }
 
     fn Location(self) -> Temporary<Location> {
diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs
index 612188f7be1..ee0abd3a3ac 100644
--- a/components/script/dom/element.rs
+++ b/components/script/dom/element.rs
@@ -581,7 +581,7 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
         let window = doc.deref().window.root();
         let list = NamedNodeMap::new(*window, self);
         self.attr_list.assign(Some(list));
-        Temporary::new(self.attr_list.get().get_ref().clone())
+        Temporary::new(self.attr_list.get().as_ref().unwrap().clone())
     }
 
     // http://dom.spec.whatwg.org/#dom-element-getattribute
@@ -830,7 +830,7 @@ pub fn get_attribute_parts<'a>(name: &'a str) -> (Option<&'a str>, &'a str) {
     //FIXME: Throw for XML-invalid names
     //FIXME: Throw for XMLNS-invalid names
     let (prefix, local_name) = if name.contains(":")  {
-        let mut parts = name.splitn(':', 1);
+        let mut parts = name.splitn(1, ':');
         (Some(parts.next().unwrap()), parts.next().unwrap())
     } else {
         (None, name)
diff --git a/components/script/dom/eventtarget.rs b/components/script/dom/eventtarget.rs
index ebe904bc476..62404fe4004 100644
--- a/components/script/dom/eventtarget.rs
+++ b/components/script/dom/eventtarget.rs
@@ -185,7 +185,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         let source: Vec<u16> = source.as_slice().utf16_units().collect();
         let handler = unsafe {
                 JS_CompileUCFunction(cx,
-                                     ptr::mut_null(),
+                                     ptr::null_mut(),
                                      name.as_ptr(),
                                      nargs,
                                      &arg_names as *const *const i8 as *mut *const i8,
@@ -254,7 +254,7 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
             Some(listener) => {
                 let mut handlers = self.handlers.deref().borrow_mut();
                 let mut entry = handlers.find_mut(&ty);
-                for entry in entry.mut_iter() {
+                for entry in entry.iter_mut() {
                     let phase = if capture { Capturing } else { Bubbling };
                     let old_entry = EventListenerEntry {
                         phase: phase,
diff --git a/components/script/dom/formdata.rs b/components/script/dom/formdata.rs
index 4374a55067e..4a023505244 100644
--- a/components/script/dom/formdata.rs
+++ b/components/script/dom/formdata.rs
@@ -73,7 +73,7 @@ impl<'a> FormDataMethods for JSRef<'a, FormData> {
 
     fn Get(self, name: DOMString) -> Option<FileOrString> {
         if self.data.deref().borrow().contains_key_equiv(&name) {
-            match self.data.deref().borrow().get(&name)[0].clone() {
+            match (*self.data.deref().borrow())[name][0].clone() {
                 StringData(ref s) => Some(eString(s.clone())),
                 FileData(ref f) => {
                     Some(eFile(f.clone()))
diff --git a/components/script/dom/htmlcollection.rs b/components/script/dom/htmlcollection.rs
index 6a4baf3f5dc..b321d40b4eb 100644
--- a/components/script/dom/htmlcollection.rs
+++ b/components/script/dom/htmlcollection.rs
@@ -23,7 +23,7 @@ pub trait CollectionFilter {
     fn filter(&self, elem: JSRef<Element>, root: JSRef<Node>) -> bool;
 }
 
-impl<S: Encoder<E>, E> Encodable<S, E> for Box<CollectionFilter> {
+impl<S: Encoder<E>, E> Encodable<S, E> for Box<CollectionFilter+'static> {
     fn encode(&self, _s: &mut S) -> Result<(), E> {
         Ok(())
     }
@@ -33,7 +33,7 @@ impl<S: Encoder<E>, E> Encodable<S, E> for Box<CollectionFilter> {
 #[must_root]
 pub enum CollectionTypeId {
     Static(Vec<JS<Element>>),
-    Live(JS<Node>, Box<CollectionFilter>)
+    Live(JS<Node>, Box<CollectionFilter+'static>)
 }
 
 #[deriving(Encodable)]
@@ -59,7 +59,7 @@ impl HTMLCollection {
 
 impl HTMLCollection {
     pub fn create(window: JSRef<Window>, root: JSRef<Node>,
-                  filter: Box<CollectionFilter>) -> Temporary<HTMLCollection> {
+                  filter: Box<CollectionFilter+'static>) -> Temporary<HTMLCollection> {
         HTMLCollection::new(window, Live(JS::from_rooted(root), filter))
     }
 
diff --git a/components/script/dom/htmloptionelement.rs b/components/script/dom/htmloptionelement.rs
index 156749fb623..31562953cd9 100644
--- a/components/script/dom/htmloptionelement.rs
+++ b/components/script/dom/htmloptionelement.rs
@@ -78,8 +78,8 @@ impl<'a> HTMLOptionElementMethods for JSRef<'a, HTMLOptionElement> {
     }
 
     // http://www.whatwg.org/html/#dom-option-text
-    fn Text(&self) -> DOMString {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn Text(self) -> DOMString {
+        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();
@@ -87,8 +87,8 @@ impl<'a> HTMLOptionElementMethods for JSRef<'a, HTMLOptionElement> {
     }
 
     // http://www.whatwg.org/html/#dom-option-text
-    fn SetText(&self, value: DOMString) {
-        let node: JSRef<Node> = NodeCast::from_ref(*self);
+    fn SetText(self, value: DOMString) {
+        let node: JSRef<Node> = NodeCast::from_ref(self);
         node.SetTextContent(Some(value))
     }
 }
diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs
index 786445bf628..40b3aa57085 100644
--- a/components/script/dom/node.rs
+++ b/components/script/dom/node.rs
@@ -657,7 +657,7 @@ impl<'m, 'n> NodeHelpers<'m, 'n> for JSRef<'n, Node> {
     }
 
     fn owner_doc(&self) -> Temporary<Document> {
-        Temporary::new(self.owner_doc.get().get_ref().clone())
+        Temporary::new(self.owner_doc.get().as_ref().unwrap().clone())
     }
 
     fn set_owner_doc(&self, document: JSRef<Document>) {
@@ -869,7 +869,7 @@ impl<'a> Iterator<JSRef<'a, Node>> for AncestorIterator<'a> {
         }
 
         // FIXME: Do we need two clones here?
-        let x = self.current.get_ref().clone();
+        let x = self.current.as_ref().unwrap().clone();
         self.current = x.parent_node().map(|node| (*node.root()).clone());
         Some(x)
     }
@@ -1236,7 +1236,7 @@ impl Node {
 
         // Step 7: mutation records.
         // Step 8.
-        for node in nodes.mut_iter() {
+        for node in nodes.iter_mut() {
             parent.add_child(*node, child);
             let is_in_doc = parent.is_in_doc();
             for kid in node.traverse_preorder() {
@@ -1571,7 +1571,7 @@ impl<'a> NodeMethods for JSRef<'a, Node> {
         let window = doc.deref().window.root();
         let child_list = NodeList::new_child_list(*window, self);
         self.child_list.assign(Some(child_list));
-        Temporary::new(self.child_list.get().get_ref().clone())
+        Temporary::new(self.child_list.get().as_ref().unwrap().clone())
     }
 
     // http://dom.spec.whatwg.org/#dom-node-firstchild
@@ -2023,12 +2023,12 @@ impl Reflectable for Node {
     }
 }
 
-pub fn document_from_node<T: NodeBase>(derived: JSRef<T>) -> Temporary<Document> {
+pub fn document_from_node<T: NodeBase+Reflectable>(derived: JSRef<T>) -> Temporary<Document> {
     let node: JSRef<Node> = NodeCast::from_ref(derived);
     node.owner_doc()
 }
 
-pub fn window_from_node<T: NodeBase>(derived: JSRef<T>) -> Temporary<Window> {
+pub fn window_from_node<T: NodeBase+Reflectable>(derived: JSRef<T>) -> Temporary<Window> {
     let document = document_from_node(derived).root();
     Temporary::new(document.deref().window.clone())
 }
diff --git a/components/script/dom/urlsearchparams.rs b/components/script/dom/urlsearchparams.rs
index ea8d7da7002..f675e01d014 100644
--- a/components/script/dom/urlsearchparams.rs
+++ b/components/script/dom/urlsearchparams.rs
@@ -14,7 +14,7 @@ use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use servo_util::str::DOMString;
 
 use encoding::all::UTF_8;
-use encoding::types::{Encoding, EncodeReplace};
+use encoding::types::{EncodingRef, EncodeReplace};
 
 use std::cell::RefCell;
 use std::collections::hashmap::HashMap;
@@ -93,14 +93,14 @@ impl Reflectable for URLSearchParams {
 }
 
 pub trait URLSearchParamsHelpers {
-    fn serialize(&self, encoding: Option<&'static Encoding>) -> Vec<u8>;
+    fn serialize(&self, encoding: Option<EncodingRef>) -> Vec<u8>;
     fn update_steps(&self);
 }
 
 impl URLSearchParamsHelpers for URLSearchParams {
-    fn serialize(&self, encoding: Option<&'static Encoding>) -> Vec<u8> {
+    fn serialize(&self, encoding: Option<EncodingRef>) -> Vec<u8> {
         // http://url.spec.whatwg.org/#concept-urlencoded-serializer
-        fn serialize_string(value: &DOMString, encoding: &'static Encoding) -> Vec<u8> {
+        fn serialize_string(value: &DOMString, encoding: EncodingRef) -> Vec<u8> {
             // http://url.spec.whatwg.org/#concept-urlencoded-byte-serializer
 
             let value = value.as_slice();
@@ -126,7 +126,7 @@ impl URLSearchParamsHelpers for URLSearchParams {
             }
             buf
         }
-        let encoding = encoding.unwrap_or(UTF_8 as &'static Encoding);
+        let encoding = encoding.unwrap_or(UTF_8 as EncodingRef);
         let mut buf = vec!();
         let mut first_pair = true;
         for (k, v) in self.data.deref().borrow().iter() {
diff --git a/components/script/dom/virtualmethods.rs b/components/script/dom/virtualmethods.rs
index 43c2d7184bd..d2332fcce1f 100644
--- a/components/script/dom/virtualmethods.rs
+++ b/components/script/dom/virtualmethods.rs
@@ -138,82 +138,82 @@ pub trait VirtualMethods {
 /// method call on the trait object will invoke the corresponding method on the
 /// concrete type, propagating up the parent hierarchy unless otherwise
 /// interrupted.
-pub fn vtable_for<'a>(node: &'a JSRef<Node>) -> &'a VirtualMethods {
+pub fn vtable_for<'a>(node: &'a JSRef<'a, Node>) -> &'a VirtualMethods + 'a {
     match node.type_id() {
         ElementNodeTypeId(HTMLAnchorElementTypeId) => {
-            let element: &JSRef<HTMLAnchorElement> = HTMLAnchorElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLAnchorElement> = HTMLAnchorElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLAreaElementTypeId) => {
-            let element: &JSRef<HTMLAreaElement> = HTMLAreaElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLAreaElement> = HTMLAreaElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLBodyElementTypeId) => {
-            let element: &JSRef<HTMLBodyElement> = HTMLBodyElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLBodyElement> = HTMLBodyElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLButtonElementTypeId) => {
-            let element: &JSRef<HTMLButtonElement> = HTMLButtonElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLButtonElement> = HTMLButtonElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLCanvasElementTypeId) => {
-            let element: &JSRef<HTMLCanvasElement> = HTMLCanvasElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLCanvasElement> = HTMLCanvasElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLFieldSetElementTypeId) => {
-            let element: &JSRef<HTMLFieldSetElement> = HTMLFieldSetElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLFieldSetElement> = HTMLFieldSetElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLImageElementTypeId) => {
-            let element: &JSRef<HTMLImageElement> = HTMLImageElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLImageElement> = HTMLImageElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLIFrameElementTypeId) => {
-            let element: &JSRef<HTMLIFrameElement> = HTMLIFrameElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLIFrameElement> = HTMLIFrameElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLInputElementTypeId) => {
-            let element: &JSRef<HTMLInputElement> = HTMLInputElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLInputElement> = HTMLInputElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLLinkElementTypeId) => {
-            let element: &JSRef<HTMLLinkElement> = HTMLLinkElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLLinkElement> = HTMLLinkElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLObjectElementTypeId) => {
-            let element: &JSRef<HTMLObjectElement> = HTMLObjectElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLObjectElement> = HTMLObjectElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLOptGroupElementTypeId) => {
-            let element: &JSRef<HTMLOptGroupElement> = HTMLOptGroupElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLOptGroupElement> = HTMLOptGroupElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLOptionElementTypeId) => {
-            let element: &JSRef<HTMLOptionElement> = HTMLOptionElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLOptionElement> = HTMLOptionElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLSelectElementTypeId) => {
-            let element: &JSRef<HTMLSelectElement> = HTMLSelectElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLSelectElement> = HTMLSelectElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLStyleElementTypeId) => {
-            let element: &JSRef<HTMLStyleElement> = HTMLStyleElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLStyleElement> = HTMLStyleElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(HTMLTextAreaElementTypeId) => {
-            let element: &JSRef<HTMLTextAreaElement> = HTMLTextAreaElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLTextAreaElement> = HTMLTextAreaElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(ElementTypeId) => {
-            let element: &JSRef<Element> = ElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, Element> = ElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         ElementNodeTypeId(_) => {
-            let element: &JSRef<HTMLElement> = HTMLElementCast::to_borrowed_ref(node).unwrap();
-            element as &VirtualMethods
+            let element: &'a JSRef<'a, HTMLElement> = HTMLElementCast::to_borrowed_ref(node).unwrap();
+            element as &'a VirtualMethods + 'a
         }
         _ => {
-            node as &VirtualMethods
+            node as &'a VirtualMethods + 'a
         }
     }
 }
diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs
index 631dfbec858..371e33d4588 100644
--- a/components/script/dom/window.rs
+++ b/components/script/dom/window.rs
@@ -48,6 +48,7 @@ use std::hash::{Hash, sip};
 use std::io::timer::Timer;
 use std::ptr;
 use std::rc::Rc;
+use std::time::duration::Duration;
 use time;
 
 #[deriving(PartialEq, Encodable, Eq)]
@@ -85,7 +86,7 @@ pub struct Window {
     pub image_cache_task: ImageCacheTask,
     pub active_timers: Traceable<RefCell<HashMap<TimerId, TimerHandle>>>,
     next_timer_handle: Traceable<Cell<i32>>,
-    pub compositor: Untraceable<Box<ScriptListener>>,
+    pub compositor: Untraceable<Box<ScriptListener+'static>>,
     pub browser_context: Traceable<RefCell<Option<BrowserContext>>>,
     pub page: Rc<Page>,
     performance: Cell<Option<JS<Performance>>>,
@@ -97,7 +98,7 @@ pub struct Window {
 impl Window {
     pub fn get_cx(&self) -> *mut JSContext {
         let js_info = self.page().js_info();
-        (**js_info.get_ref().js_context).ptr
+        (**js_info.as_ref().unwrap().js_context).ptr
     }
 
     pub fn page<'a>(&'a self) -> &'a Page {
@@ -111,7 +112,7 @@ impl Window {
 #[unsafe_destructor]
 impl Drop for Window {
     fn drop(&mut self) {
-        for (_, timer_handle) in self.active_timers.borrow_mut().mut_iter() {
+        for (_, timer_handle) in self.active_timers.borrow_mut().iter_mut() {
             timer_handle.cancel();
         }
     }
@@ -214,7 +215,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
 
     fn Document(self) -> Temporary<Document> {
         let frame = self.page().frame();
-        Temporary::new(frame.get_ref().document.clone())
+        Temporary::new(frame.as_ref().unwrap().document.clone())
     }
 
     fn Location(self) -> Temporary<Location> {
@@ -223,7 +224,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
             let location = Location::new(self, page);
             self.location.assign(Some(location));
         }
-        Temporary::new(self.location.get().get_ref().clone())
+        Temporary::new(self.location.get().as_ref().unwrap().clone())
     }
 
     fn Console(self) -> Temporary<Console> {
@@ -231,7 +232,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
             let console = Console::new(&global::Window(self));
             self.console.assign(Some(console));
         }
-        Temporary::new(self.console.get().get_ref().clone())
+        Temporary::new(self.console.get().as_ref().unwrap().clone())
     }
 
     fn Navigator(self) -> Temporary<Navigator> {
@@ -239,7 +240,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
             let navigator = Navigator::new(self);
             self.navigator.assign(Some(navigator));
         }
-        Temporary::new(self.navigator.get().get_ref().clone())
+        Temporary::new(self.navigator.get().as_ref().unwrap().clone())
     }
 
     fn SetTimeout(self, _cx: *mut JSContext, callback: JSVal, timeout: i32) -> i32 {
@@ -287,7 +288,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
             let performance = Performance::new(self);
             self.performance.assign(Some(performance));
         }
-        Temporary::new(self.performance.get().get_ref().clone())
+        Temporary::new(self.performance.get().as_ref().unwrap().clone())
     }
 
     fn GetOnclick(self) -> Option<EventHandlerNonNull> {
@@ -335,7 +336,7 @@ impl<'a> WindowMethods for JSRef<'a, Window> {
             let screen = Screen::new(self);
             self.screen.assign(Some(screen));
         }
-        Temporary::new(self.screen.get().get_ref().clone())
+        Temporary::new(self.screen.get().as_ref().unwrap().clone())
     }
 
     fn Debug(self, message: DOMString) {
@@ -444,7 +445,7 @@ impl<'a> WindowHelpers for JSRef<'a, Window> {
             let mut rval = NullValue();
             unsafe {
                 JS_CallFunctionValue(cx, this_value, *data.funval,
-                                     0, ptr::mut_null(), &mut rval);
+                                     0, ptr::null_mut(), &mut rval);
             }
         });
 
@@ -473,10 +474,11 @@ impl<'a> PrivateWindowHelpers for JSRef<'a, Window> {
         };
         spawn_named(spawn_name, proc() {
             let mut tm = tm;
+            let duration = Duration::milliseconds(timeout as i64);
             let timeout_port = if is_interval {
-                tm.periodic(timeout)
+                tm.periodic(duration)
             } else {
-                tm.oneshot(timeout)
+                tm.oneshot(duration)
             };
             let cancel_port = cancel_port;
 
@@ -519,7 +521,7 @@ impl Window {
                page: Rc<Page>,
                script_chan: ScriptChan,
                control_chan: ScriptControlChan,
-               compositor: Box<ScriptListener>,
+               compositor: Box<ScriptListener+'static>,
                image_cache_task: ImageCacheTask)
                -> Temporary<Window> {
         let win = box Window {
diff --git a/components/script/dom/worker.rs b/components/script/dom/worker.rs
index af7302a1671..a0d8f4685cd 100644
--- a/components/script/dom/worker.rs
+++ b/components/script/dom/worker.rs
@@ -89,7 +89,7 @@ impl Worker {
             assert!(JS_ReadStructuredClone(
                 global.root_ref().get_cx(), data as *const u64, nbytes,
                 JS_STRUCTURED_CLONE_VERSION, &mut message,
-                ptr::null(), ptr::mut_null()) != 0);
+                ptr::null(), ptr::null_mut()) != 0);
         }
 
         let target: JSRef<EventTarget> = EventTargetCast::from_ref(*worker);
@@ -131,11 +131,11 @@ impl Worker {
 
 impl<'a> WorkerMethods for JSRef<'a, Worker> {
     fn PostMessage(self, cx: *mut JSContext, message: JSVal) {
-        let mut data = ptr::mut_null();
+        let mut data = ptr::null_mut();
         let mut nbytes = 0;
         unsafe {
             assert!(JS_WriteStructuredClone(cx, message, &mut data, &mut nbytes,
-                                            ptr::null(), ptr::mut_null()) != 0);
+                                            ptr::null(), ptr::null_mut()) != 0);
         }
 
         self.addref();
diff --git a/components/script/dom/workerglobalscope.rs b/components/script/dom/workerglobalscope.rs
index b0df64f0b11..f5bb583fddb 100644
--- a/components/script/dom/workerglobalscope.rs
+++ b/components/script/dom/workerglobalscope.rs
@@ -88,12 +88,12 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
             let location = WorkerLocation::new(self, self.worker_url.deref().clone());
             self.location.assign(Some(location));
         }
-        Temporary::new(self.location.get().get_ref().clone())
+        Temporary::new(self.location.get().as_ref().unwrap().clone())
     }
 
     fn ImportScripts(self, url_strings: Vec<DOMString>) -> ErrorResult {
         let mut urls = Vec::with_capacity(url_strings.len());
-        for url in url_strings.move_iter() {
+        for url in url_strings.into_iter() {
             let url = UrlParser::new().base_url(&*self.worker_url)
                                       .parse(url.as_slice());
             match url {
@@ -102,7 +102,7 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
             };
         }
 
-        for url in urls.move_iter() {
+        for url in urls.into_iter() {
             let (url, source) = match load_whole_resource(&*self.resource_task, url) {
                 Err(_) => return Err(Network),
                 Ok((metadata, bytes)) => {
@@ -128,7 +128,7 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
             let navigator = WorkerNavigator::new(self);
             self.navigator.assign(Some(navigator));
         }
-        Temporary::new(self.navigator.get().get_ref().clone())
+        Temporary::new(self.navigator.get().as_ref().unwrap().clone())
     }
 
     fn Console(self) -> Temporary<Console> {
@@ -136,7 +136,7 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
             let console = Console::new(&global::Worker(self));
             self.console.assign(Some(console));
         }
-        Temporary::new(self.console.get().get_ref().clone())
+        Temporary::new(self.console.get().as_ref().unwrap().clone())
     }
 
     fn Btoa(self, btoa: DOMString) -> Fallible<DOMString> {
diff --git a/components/script/dom/xmlhttprequest.rs b/components/script/dom/xmlhttprequest.rs
index 42ff2f483cb..d2813f505b0 100644
--- a/components/script/dom/xmlhttprequest.rs
+++ b/components/script/dom/xmlhttprequest.rs
@@ -28,8 +28,8 @@ use encoding::all::UTF_8;
 use encoding::label::encoding_from_whatwg_label;
 use encoding::types::{DecodeReplace, Encoding, EncodingRef, EncodeReplace};
 
-use ResponseHeaderCollection = http::headers::response::HeaderCollection;
-use RequestHeaderCollection = http::headers::request::HeaderCollection;
+use http::headers::response::HeaderCollection as ResponseHeaderCollection;
+use http::headers::request::HeaderCollection as RequestHeaderCollection;
 use http::headers::content_type::MediaType;
 use http::headers::{HeaderEnum, HeaderValueByteIterator};
 use http::headers::request::Header;
@@ -56,6 +56,8 @@ use std::io::{BufReader, MemWriter, Timer};
 use std::from_str::FromStr;
 use std::path::BytesContainer;
 use std::task::TaskBuilder;
+use std::time::duration::Duration;
+use std::num::Zero;
 use time;
 use url::{Url, UrlParser};
 
@@ -538,7 +540,7 @@ impl<'a> XMLHttpRequestMethods for JSRef<'a, XMLHttpRequest> {
                 referer_url.serialize_host().map(|ref h| buf.push_str(h.as_slice()));
                 referer_url.port().as_ref().map(|&p| {
                     buf.push_str(":".as_slice());
-                    buf.push_str(p);
+                    buf.push_str(format!("{:u}", p).as_slice());
                 });
                 referer_url.serialize_path().map(|ref h| buf.push_str(h.as_slice()));
                 self.request_headers.deref().borrow_mut().referer = Some(buf);
@@ -888,7 +890,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
     fn set_timeout(self, timeout: u32) {
         // Sets up the object to timeout in a given number of milliseconds
         // This will cancel all previous timeouts
-        let oneshot = self.timer.deref().borrow_mut().oneshot(timeout as u64);
+        let oneshot = self.timer.deref().borrow_mut()
+                          .oneshot(Duration::milliseconds(timeout as i64));
         let addr = unsafe {
             self.to_trusted() // This will increment the pin counter by one
         };
@@ -923,7 +926,7 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
             self.release_once();
         }
         // oneshot() closes the previous channel, canceling the timeout
-        self.timer.deref().borrow_mut().oneshot(0);
+        self.timer.deref().borrow_mut().oneshot(Zero::zero());
     }
     fn text_response(self) -> DOMString {
         let mut encoding = UTF_8 as EncodingRef;
diff --git a/components/script/html/hubbub_html_parser.rs b/components/script/html/hubbub_html_parser.rs
index 96f23174a61..097f8438cb5 100644
--- a/components/script/html/hubbub_html_parser.rs
+++ b/components/script/html/hubbub_html_parser.rs
@@ -519,7 +519,7 @@ pub fn parse_html(page: &Page,
             let load_response = load_response.unwrap();
             match load_response.metadata.content_type {
                 Some((ref t, _)) if t.as_slice().eq_ignore_ascii_case("image") => {
-                    let page = format!("<html><body><img src='{:s}' /></body></html>", base_url.get_ref().serialize());
+                    let page = format!("<html><body><img src='{:s}' /></body></html>", base_url.as_ref().unwrap().serialize());
                     parser.parse_chunk(page.into_bytes().as_slice());
                 },
                 _ => loop {
diff --git a/components/script/lib.rs b/components/script/lib.rs
index 329185e3058..c4b6b675d42 100644
--- a/components/script/lib.rs
+++ b/components/script/lib.rs
@@ -8,7 +8,7 @@
 #![feature(globs, macro_rules, struct_variant, phase, unsafe_destructor)]
 
 #![deny(unused_imports, unused_variable)]
-#![allow(non_snake_case_functions)]
+#![allow(non_snake_case)]
 
 #![doc="The script crate contains all matters DOM."]
 
@@ -33,12 +33,12 @@ extern crate time;
 extern crate canvas;
 extern crate script_traits;
 #[phase(plugin)]
-extern crate servo_macros = "macros";
-extern crate servo_net = "net";
-extern crate servo_util = "util";
+extern crate "macros" as servo_macros;
+extern crate "net" as servo_net;
+extern crate "util" as servo_util;
 extern crate style;
 extern crate sync;
-extern crate servo_msg = "msg";
+extern crate "msg" as servo_msg;
 extern crate url;
 extern crate uuid;
 
diff --git a/components/script/page.rs b/components/script/page.rs
index c4a2a217fec..a9469609576 100644
--- a/components/script/page.rs
+++ b/components/script/page.rs
@@ -56,7 +56,7 @@ pub struct Page {
     pub layout_chan: Untraceable<LayoutChan>,
 
     /// A handle to perform RPC calls into the layout, quickly.
-    layout_rpc: Untraceable<Box<LayoutRPC>>,
+    layout_rpc: Untraceable<Box<LayoutRPC+'static>>,
 
     /// The port that we will use to join layout. If this is `None`, then layout is not running.
     pub layout_join_port: Untraceable<RefCell<Option<Receiver<()>>>>,
@@ -169,8 +169,8 @@ impl Page {
         let damaged = self.damage.borrow().is_some();
         if damaged {
             let frame = self.frame();
-            let window = frame.get_ref().window.root();
-            self.reflow(goal, window.control_chan.clone(), *window.compositor);
+            let window = frame.as_ref().unwrap().window.root();
+            self.reflow(goal, window.control_chan.clone(), &**window.compositor);
         } else {
             self.avoided_reflows.set(self.avoided_reflows.get() + 1);
         }
@@ -182,7 +182,7 @@ impl Page {
         // doing a query reflow.
         self.flush_layout(ReflowForDisplay);
         self.join_layout(); //FIXME: is this necessary, or is layout_rpc's mutex good enough?
-        let layout_rpc: &LayoutRPC = *self.layout_rpc;
+        let layout_rpc: &LayoutRPC = &**self.layout_rpc;
         layout_rpc
     }
 
@@ -192,7 +192,7 @@ impl Page {
             self.children
                 .deref()
                 .borrow_mut()
-                .mut_iter()
+                .iter_mut()
                 .enumerate()
                 .find(|&(_idx, ref page_tree)| {
                     // FIXME: page_tree has a lifetime such that it's unusable for anything.
@@ -204,7 +204,7 @@ impl Page {
         match remove_idx {
             Some(idx) => return Some(self.children.deref().borrow_mut().remove(idx).unwrap()),
             None => {
-                for page_tree in self.children.deref().borrow_mut().mut_iter() {
+                for page_tree in self.children.deref().borrow_mut().iter_mut() {
                     match page_tree.remove(id) {
                         found @ Some(_) => return found,
                         None => (), // keep going...
@@ -292,7 +292,7 @@ impl Page {
     }
 
     pub fn get_url(&self) -> Url {
-        self.url().get_ref().ref0().clone()
+        self.url().as_ref().unwrap().ref0().clone()
     }
 
     // FIXME(cgaebel): join_layout is racey. What if the compositor triggers a
@@ -393,7 +393,7 @@ impl Page {
 
     /// Attempt to find a named element in this page's document.
     pub fn find_fragment_node(&self, fragid: DOMString) -> Option<Temporary<Element>> {
-        let document = self.frame().get_ref().document.root();
+        let document = self.frame().as_ref().unwrap().document.root();
         match document.deref().GetElementById(fragid.to_string()) {
             Some(node) => Some(node),
             None => {
@@ -412,7 +412,7 @@ impl Page {
 
     pub fn hit_test(&self, point: &Point2D<f32>) -> Option<UntrustedNodeAddress> {
         let frame = self.frame();
-        let document = frame.get_ref().document.root();
+        let document = frame.as_ref().unwrap().document.root();
         let root = document.deref().GetDocumentElement().root();
         if root.is_none() {
             return None;
@@ -433,7 +433,7 @@ impl Page {
 
     pub fn get_nodes_under_mouse(&self, point: &Point2D<f32>) -> Option<Vec<UntrustedNodeAddress>> {
         let frame = self.frame();
-        let document = frame.get_ref().document.root();
+        let document = frame.as_ref().unwrap().document.root();
         let root = document.deref().GetDocumentElement().root();
         if root.is_none() {
             return None;
diff --git a/components/script/script_task.rs b/components/script/script_task.rs
index c7404920690..9aed829a633 100644
--- a/components/script/script_task.rs
+++ b/components/script/script_task.rs
@@ -163,7 +163,7 @@ pub struct ScriptTask {
     /// For communicating load url messages to the constellation
     constellation_chan: ConstellationChan,
     /// A handle to the compositor for communicating ready state messages.
-    compositor: Box<ScriptListener>,
+    compositor: Box<ScriptListener+'static>,
 
     /// For providing instructions to an optional devtools server.
     devtools_chan: Option<DevtoolsControlChan>,
@@ -243,7 +243,7 @@ impl ScriptTaskFactory for ScriptTask {
         box pair.sender() as Box<Any+Send>
     }
 
-    fn create<C:ScriptListener + Send>(
+    fn create<C:ScriptListener + Send + 'static>(
                   _phantom: Option<&mut ScriptTask>,
                   id: PipelineId,
                   compositor: Box<C>,
@@ -284,7 +284,7 @@ impl ScriptTaskFactory for ScriptTask {
 impl ScriptTask {
     /// Creates a new script task.
     pub fn new(id: PipelineId,
-               compositor: Box<ScriptListener>,
+               compositor: Box<ScriptListener+'static>,
                layout_chan: LayoutChan,
                port: Receiver<ScriptMsg>,
                chan: ScriptChan,
@@ -376,7 +376,7 @@ impl ScriptTask {
     }
 
     pub fn get_cx(&self) -> *mut JSContext {
-        (**self.js_context.borrow().get_ref()).ptr
+        (**self.js_context.borrow().as_ref().unwrap()).ptr
     }
 
     /// Starts the script task. After calling this method, the script task will loop receiving
@@ -412,7 +412,7 @@ impl ScriptTask {
             }
         }
 
-        for (id, size) in resizes.move_iter() {
+        for (id, size) in resizes.into_iter() {
             self.handle_event(id, ResizeEvent(size));
         }
 
@@ -485,7 +485,7 @@ impl ScriptTask {
         }
 
         // Process the gathered events.
-        for msg in sequential.move_iter() {
+        for msg in sequential.into_iter() {
             match msg {
                 // TODO(tkuehn) need to handle auxiliary layouts for iframes
                 FromConstellation(AttachLayoutMsg(_)) => fail!("should have handled AttachLayoutMsg already"),
@@ -605,7 +605,7 @@ impl ScriptTask {
                       window_size,
                       parent_page.resource_task.deref().clone(),
                       self.constellation_chan.clone(),
-                      self.js_context.borrow().get_ref().clone())
+                      self.js_context.borrow().as_ref().unwrap().clone())
         };
         parent_page.children.deref().borrow_mut().push(Rc::new(new_page));
     }
@@ -616,7 +616,7 @@ impl ScriptTask {
         let page = page.find(id).expect("ScriptTask: received fire timer msg for a
             pipeline ID not associated with this script task. This is a bug.");
         let frame = page.frame();
-        let window = frame.get_ref().window.root();
+        let window = frame.as_ref().unwrap().window.root();
         window.handle_fire_timer(timer_id, self.get_cx());
     }
 
@@ -638,7 +638,7 @@ impl ScriptTask {
         if page.pending_reflows.get() > 0 {
             page.pending_reflows.set(0);
             page.damage(MatchSelectorsDocumentDamage);
-            page.reflow(ReflowForDisplay, self.control_chan.clone(), self.compositor);
+            page.reflow(ReflowForDisplay, self.control_chan.clone(), &*self.compositor);
         }
     }
 
@@ -718,7 +718,7 @@ impl ScriptTask {
                 *page.mut_url() = Some((loaded.clone(), false));
                 if needs_reflow {
                     page.damage(ContentChangedDocumentDamage);
-                    page.reflow(ReflowForDisplay, self.control_chan.clone(), self.compositor);
+                    page.reflow(ReflowForDisplay, self.control_chan.clone(), &*self.compositor);
                 }
                 return;
             },
@@ -729,7 +729,7 @@ impl ScriptTask {
         let last_url = last_loaded_url.map(|(ref loaded, _)| loaded.clone());
 
         let cx = self.js_context.borrow();
-        let cx = cx.get_ref();
+        let cx = cx.as_ref().unwrap();
         // Create the window and document objects.
         let window = Window::new(cx.deref().ptr,
                                  page.clone(),
@@ -742,7 +742,7 @@ impl ScriptTask {
                 Some(url) => Some(url.clone()),
                 None => Url::parse("about:blank").ok(),
             };
-            *page.mut_url() = Some((doc_url.get_ref().clone(), true));
+            *page.mut_url() = Some((doc_url.as_ref().unwrap().clone(), true));
             doc_url
         } else {
             Some(url.clone())
@@ -879,7 +879,7 @@ impl ScriptTask {
                     let frame = page.frame();
                     if frame.is_some() {
                         page.damage(ReflowDocumentDamage);
-                        page.reflow(ReflowForDisplay, self.control_chan.clone(), self.compositor)
+                        page.reflow(ReflowForDisplay, self.control_chan.clone(), &*self.compositor)
                     }
 
                     let mut fragment_node = page.fragment_node.get();
@@ -919,7 +919,7 @@ impl ScriptTask {
                         page.pending_reflows.set(page.pending_reflows.get() + 1);
                     } else {
                         page.damage(MatchSelectorsDocumentDamage);
-                        page.reflow(ReflowForDisplay, self.control_chan.clone(), self.compositor)
+                        page.reflow(ReflowForDisplay, self.control_chan.clone(), &*self.compositor)
                     }
                 }
             }
@@ -974,7 +974,7 @@ impl ScriptTask {
                         let mouse_over_targets = &mut *self.mouse_over_targets.borrow_mut();
                         match *mouse_over_targets {
                             Some(ref mut mouse_over_targets) => {
-                                for node in mouse_over_targets.mut_iter() {
+                                for node in mouse_over_targets.iter_mut() {
                                     let node = node.root();
                                     node.deref().set_hover_state(false);
                                 }
@@ -1018,7 +1018,7 @@ impl ScriptTask {
                         if target_compare {
                             if mouse_over_targets.is_some() {
                                 page.damage(MatchSelectorsDocumentDamage);
-                                page.reflow(ReflowForDisplay, self.control_chan.clone(), self.compositor);
+                                page.reflow(ReflowForDisplay, self.control_chan.clone(), &*self.compositor);
                             }
                             *mouse_over_targets = Some(target_list);
                         }