script: Optimize JS rooting to not move the entire Root struct from

the stack to the return out-pointer.

This was showing up very high in instruction-level profiling.

components/script/dom/bindings/js.rs

@@ -626,12 +626,12 @@ impl RootCollection {
         }
     }
 
-    /// Track a stack-based root to ensure LIFO root ordering
+    /// Track a stack-based root as a pointer to ensure LIFO root ordering.
-    fn root<'b, T: Reflectable>(&self, untracked: &Root<T>) {
+    fn root<'b>(&self, untracked_js_ptr: *mut JSObject) {
         unsafe {
             let roots = self.roots.get();
-            (*roots).push(untracked.js_ptr);
+            (*roots).push(untracked_js_ptr);
-            debug!("  rooting {:?}", untracked.js_ptr);
+            debug!("  rooting {:?}", untracked_js_ptr);
             assert!(!(*roots).spilled());
         }
     }
@@ -668,15 +668,18 @@ impl<T: Reflectable> Root<T> {
     /// Create a new stack-bounded root for the provided JS-owned value.
     /// It cannot not outlive its associated `RootCollection`, and it contains
     /// a `JSRef` which cannot outlive this new `Root`.
+    #[inline]
     fn new(roots: &'static RootCollection, unrooted: NonZero<*const T>)
            -> Root<T> {
-        let root = Root {
+        let js_ptr = unsafe {
+            (**unrooted).reflector().get_jsobject()
+        };
+        roots.root(js_ptr);
+        Root {
             root_list: roots,
             ptr: unrooted,
-            js_ptr: unsafe { (**unrooted).reflector().get_jsobject() },
+            js_ptr: js_ptr,
-        };
+        }
-        roots.root(&root);
-        root
     }
 
     /// Obtain a safe reference to the wrapped JS owned-value that cannot