Auto merge of #6150 - servo:smupgrade3, r=mbrubeck

Upgrade to Spidermonkey 39

> Here it is.
> 
> ~~There's two major things that are unfinished here:~~
> - ~~Dealing with the unroot_must_root lint. I'm not sure about the value of this lint with the new rooting API.~~ Done.
> - ~~Updating the Cargo.locks to point to the new SM and SM binding.~~ Done.
> 
> I also included my fixes for the rust update, but these will disappear in a rebase. A rust update is necessary to support calling `Drop` on `Heap<T>` correctly when `Heap<T>` is inside a `Rc<T>`. Otherwise `&self` points to the wrong location.
> 
> Incremental GC is disabled here. I'm not sure how to deal with the incremental barriers so that's left for later.
> 
> Generational GC works. SM doesn't work without it.
> 
> The biggest change here is to the rooting API. `Root` was made movable, and `Temporary` and `JSRef` was removed. Movable `Root`s means there's no need for `Temporary`, and `JSRef`s aren't needed generally since it can be assumed that being able to obtain a reference to a dom object means it's already rooted. References have their lifetime bound to the Roots that provided them. DOM objects that haven't passed through `reflect_dom_object` don't need to be rooted, and DOM objects that have passed through `reflect_dom_object` can't be obtained without being rooted through `native_from_reflector_jsmanaged` or `JS::<T>::root()`.
> 
> Support for `Heap<T>` ended up messier than I expected. It's split into two commits, but only because it's a bit difficult to fold them together. Supporting `Heap<T>` properly requires that that `Heap::<T>::set()` be called on something that won't move. I removed the Copy and Clone trait from `Heap<T>` so `Cell` can't hold `Heap<T>` - only `UnsafeCell` can hold it.
> 
> `CallbackObject` is a bit tricky - I moved all callbacks into `Rc<T>` in order to make sure that the pointer inside to a `*mut JSObject` doesn't move. This is necessary for supporting `Heap<T>`.
> 
> `RootedCollectionSet` is very general purpose now. Anything with `JSTraceable` can be rooted by `RootedCollectionSet`/`RootedTraceable`. Right now, `RootedTraceable` is only used to hold down dom objects before they're fully attached to their reflector. I had to make a custom mechanism to dispatch the trace call - couldn't figure out how to get trait objects working for this case.
> 
> This has been tested with the following zeal settings:
> 
> GC after every allocation
> JS_GC_ZEAL=2,1
> 
> GC after every 100 allocations (important for catching use-after-free bugs)
> JS_GC_ZEAL=2,100
> 
> Verify pre barriers
> JS_GC_ZEAL=4,1
> 
> Verify post barriers
> JS_GC_ZEAL=11,1

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

1 files changed, 8 insertions, 8 deletions

diff --git a/components/script/dom/userscripts.rs b/components/script/dom/userscripts.rs
index 1910784b0c5..a71ead38e52 100644
--- a/components/script/dom/userscripts.rs
+++ b/components/script/dom/userscripts.rs
@@ -5,10 +5,10 @@
 use dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
 use dom::bindings::codegen::Bindings::DocumentBinding::DocumentMethods;
 use dom::bindings::codegen::InheritTypes::NodeCast;
-use dom::bindings::js::{JSRef, OptionalRootable, Rootable, RootedReference};
+use dom::bindings::js::{RootedReference};
 use dom::element::AttributeHandlers;
 use dom::htmlheadelement::HTMLHeadElement;
-use dom::node::{Node, NodeHelpers};
+use dom::node::NodeHelpers;
 use util::opts;
 use util::resource_files::resources_dir_path;
 use std::borrow::ToOwned;
@@ -16,11 +16,11 @@ use std::fs::read_dir;
 use std::path::PathBuf;
 
 
-pub fn load_script(head: JSRef<HTMLHeadElement>) {
+pub fn load_script(head: &HTMLHeadElement) {
     if let Some(ref path_str) = opts::get().userscripts {
-        let node: &JSRef<Node> = NodeCast::from_borrowed_ref(&head);
-        let first_child = node.GetFirstChild().root();
-        let doc = node.owner_doc().root();
+        let node = NodeCast::from_borrowed_ref(&head);
+        let first_child = node.GetFirstChild();
+        let doc = node.owner_doc();
         let doc = doc.r();
 
         let path = if &**path_str == "" {
@@ -42,10 +42,10 @@ pub fn load_script(head: JSRef<HTMLHeadElement>) {
                 Ok(ref s) if s.ends_with(".js") => "file://".to_owned() + &s[..],
                 _ => continue
             };
-            let new_script = doc.CreateElement("script".to_owned()).unwrap().root();
+            let new_script = doc.CreateElement("script".to_owned()).unwrap();
             let new_script = new_script.r();
             new_script.set_string_attribute(&atom!("src"), name);
-            let new_script_node: &JSRef<Node> = NodeCast::from_borrowed_ref(&new_script);
+            let new_script_node = NodeCast::from_borrowed_ref(&new_script);
             node.InsertBefore(*new_script_node, first_child.r()).unwrap();
         }
     }