Remove JS::from_rooted

components/script/dom/bindings/js.rs

@@ -76,15 +76,6 @@ impl<T> JS<T> {
 }
 
 impl<T: Reflectable> JS<T> {
-    /// Create a JS<T> from a Root<T>
-    /// XXX Not a great API. Should be a call on Root<T> instead
-    #[allow(unrooted_must_root)]
-    pub fn from_rooted(root: &Root<T>) -> JS<T> {
-        debug_assert!(thread_state::get().is_script());
-        JS {
-            ptr: unsafe { NonZero::new(&**root) },
-        }
-    }
     /// Create a JS<T> from a &T
     #[allow(unrooted_must_root)]
     pub fn from_ref(obj: &T) -> JS<T> {

components/script/dom/bindings/trace.rs

@@ -540,7 +540,7 @@ impl<A: JSTraceable + Reflectable> FromIterator<Root<A>> for RootedVec<JS<A>> {
         let mut vec = unsafe {
             RootedVec::new_with_destination_address(return_address() as *const libc::c_void)
         };
-        vec.extend(iterable.into_iter().map(|item| JS::from_rooted(&item)));
+        vec.extend(iterable.into_iter().map(|item| JS::from_ref(&*item)));
         vec
     }
 }

components/script/dom/canvasrenderingcontext2d.rs

@@ -996,14 +996,14 @@ impl CanvasRenderingContext2DMethods for CanvasRenderingContext2D {
             }
             StringOrCanvasGradientOrCanvasPattern::CanvasGradient(gradient) => {
                 self.state.borrow_mut().fill_style =
-                    CanvasFillOrStrokeStyle::Gradient(JS::from_rooted(&gradient));
+                    CanvasFillOrStrokeStyle::Gradient(JS::from_ref(&*gradient));
                 let msg = CanvasMsg::Canvas2d(
                     Canvas2dMsg::SetFillStyle(gradient.to_fill_or_stroke_style()));
                 self.ipc_renderer.send(msg).unwrap();
             }
             StringOrCanvasGradientOrCanvasPattern::CanvasPattern(pattern) => {
                 self.state.borrow_mut().fill_style =
-                    CanvasFillOrStrokeStyle::Pattern(JS::from_rooted(&pattern));
+                    CanvasFillOrStrokeStyle::Pattern(JS::from_ref(&*pattern));
                 let msg = CanvasMsg::Canvas2d(
                     Canvas2dMsg::SetFillStyle(pattern.to_fill_or_stroke_style()));
                 self.ipc_renderer.send(msg).unwrap();

components/script/dom/document.rs

@@ -983,13 +983,13 @@ impl Document {
         match event_type {
             TouchEventType::Down => {
                 // Add a new touch point
-                self.active_touch_points.borrow_mut().push(JS::from_rooted(&touch));
+                self.active_touch_points.borrow_mut().push(JS::from_ref(&*touch));
             }
             TouchEventType::Move => {
                 // Replace an existing touch point
                 let mut active_touch_points = self.active_touch_points.borrow_mut();
                 match active_touch_points.iter_mut().find(|t| t.Identifier() == identifier) {
-                    Some(t) => *t = JS::from_rooted(&touch),
+                    Some(t) => *t = JS::from_ref(&*touch),
                     None => warn!("Got a touchmove event for a non-active touch point"),
                 }
             }
@@ -1010,7 +1010,7 @@ impl Document {
         touches.extend(self.active_touch_points.borrow().iter().cloned());
 
         let mut changed_touches = RootedVec::new();
-        changed_touches.push(JS::from_rooted(&touch));
+        changed_touches.push(JS::from_ref(&*touch));
 
         let mut target_touches = RootedVec::new();
         target_touches.extend(self.active_touch_points
@@ -1775,7 +1775,7 @@ impl Document {
                             node.get_stylesheet()
                         } else {
                             None
-                        }.map(|stylesheet| (JS::from_rooted(&node), stylesheet))
+                        }.map(|stylesheet| (JS::from_ref(&*node), stylesheet))
                     })
                     .collect());
             };
@@ -1998,7 +1998,7 @@ impl DocumentMethods for Document {
                                                                 self.upcast(),
                                                                 tag_atom,
                                                                 ascii_lower_tag);
-                entry.insert(JS::from_rooted(&result));
+                entry.insert(JS::from_ref(&*result));
                 result
             }
         }
@@ -2016,7 +2016,7 @@ impl DocumentMethods for Document {
             Occupied(entry) => Root::from_ref(entry.get()),
             Vacant(entry) => {
                 let result = HTMLCollection::by_qual_tag_name(&self.window, self.upcast(), qname);
-                entry.insert(JS::from_rooted(&result));
+                entry.insert(JS::from_ref(&*result));
                 result
             }
         }
@@ -2033,7 +2033,7 @@ impl DocumentMethods for Document {
                 let result = HTMLCollection::by_atomic_class_name(&self.window,
                                                                   self.upcast(),
                                                                   class_atoms);
-                entry.insert(JS::from_rooted(&result));
+                entry.insert(JS::from_ref(&*result));
                 result
             }
         }

components/script/dom/domrectlist.rs

@@ -22,7 +22,7 @@ impl DOMRectList {
     {
         DOMRectList {
             reflector_: Reflector::new(),
-            rects: rects.map(|r| JS::from_rooted(&r)).collect(),
+            rects: rects.map(|r| JS::from_ref(&*r)).collect(),
         }
     }
 

components/script/dom/filelist.rs

@@ -28,7 +28,7 @@ impl FileList {
 
     #[allow(unrooted_must_root)]
     pub fn new(window: &Window, files: Vec<Root<File>>) -> Root<FileList> {
-        reflect_dom_object(box FileList::new_inherited(files.iter().map(|r| JS::from_rooted(&r)).collect()),
+        reflect_dom_object(box FileList::new_inherited(files.iter().map(|r| JS::from_ref(&**r)).collect()),
                            GlobalRef::Window(window),
                            FileListBinding::Wrap)
     }

components/script/dom/formdata.rs

@@ -66,7 +66,7 @@ impl FormDataMethods for FormData {
     #[allow(unrooted_must_root)]
     // https://xhr.spec.whatwg.org/#dom-formdata-append
     fn Append_(&self, name: USVString, value: &Blob, filename: Option<USVString>) {
-        let blob = FormDatum::BlobData(JS::from_rooted(&self.get_file_or_blob(value, filename)));
+        let blob = FormDatum::BlobData(JS::from_ref(&*self.get_file_or_blob(value, filename)));
         let mut data = self.data.borrow_mut();
         match data.entry(Atom::from(name.0)) {
             Occupied(entry) => entry.into_mut().push(blob),
@@ -113,7 +113,7 @@ impl FormDataMethods for FormData {
     fn Set(&self, name: USVString, value: BlobOrUSVString) {
         let val = match value {
             BlobOrUSVString::USVString(s) => FormDatum::StringData(s.0),
-            BlobOrUSVString::Blob(b) => FormDatum::BlobData(JS::from_rooted(&b))
+            BlobOrUSVString::Blob(b) => FormDatum::BlobData(JS::from_ref(&*b))
         };
         self.data.borrow_mut().insert(Atom::from(name.0), vec!(val));
     }

components/script/dom/htmlcanvaselement.rs

@@ -145,7 +145,7 @@ impl HTMLCanvasElement {
             let window = window_from_node(self);
             let size = self.get_size();
             let context = CanvasRenderingContext2D::new(GlobalRef::Window(window.r()), self, size);
-            *self.context.borrow_mut() = Some(CanvasContext::Context2d(JS::from_rooted(&context)));
+            *self.context.borrow_mut() = Some(CanvasContext::Context2d(JS::from_ref(&*context)));
         }
 
         match *self.context.borrow().as_ref().unwrap() {
@@ -175,7 +175,7 @@ impl HTMLCanvasElement {
 
             let maybe_ctx = WebGLRenderingContext::new(GlobalRef::Window(window.r()), self, size, attrs);
 
-            *self.context.borrow_mut() = maybe_ctx.map( |ctx| CanvasContext::WebGL(JS::from_rooted(&ctx)));
+            *self.context.borrow_mut() = maybe_ctx.map( |ctx| CanvasContext::WebGL(JS::from_ref(&*ctx)));
         }
 
         if let Some(CanvasContext::WebGL(ref context)) = *self.context.borrow() {

components/script/dom/htmltableelement.rs

@@ -143,7 +143,7 @@ impl HTMLTableElementMethods for HTMLTableElement {
             sections: self.upcast::<Node>()
                           .children()
                           .filter_map(|ref node|
-                                node.downcast::<HTMLTableSectionElement>().map(|_| JS::from_rooted(node)))
+                                node.downcast::<HTMLTableSectionElement>().map(|_| JS::from_ref(&**node)))
                           .collect()
         };
         HTMLCollection::new(window_from_node(self).r(), self.upcast(), box filter)

components/script/dom/node.rs

@@ -1517,7 +1517,7 @@ impl Node {
         let mut new_nodes = RootedVec::new();
         let new_nodes = if let NodeTypeId::DocumentFragment = node.type_id() {
             // Step 3.
-            new_nodes.extend(node.children().map(|kid| JS::from_rooted(&kid)));
+            new_nodes.extend(node.children().map(|kid| JS::from_ref(&*kid)));
             // Step 4: mutation observers.
             // Step 5.
             for kid in new_nodes.r() {
@@ -1563,7 +1563,7 @@ impl Node {
         let mut added_nodes = RootedVec::new();
         let added_nodes = if let Some(node) = node.as_ref() {
             if let NodeTypeId::DocumentFragment = node.type_id() {
-                added_nodes.extend(node.children().map(|child| JS::from_rooted(&child)));
+                added_nodes.extend(node.children().map(|child| JS::from_ref(&*child)));
                 added_nodes.r()
             } else {
                 ref_slice(node)
@@ -2106,7 +2106,7 @@ impl NodeMethods for Node {
         // Step 12.
         let mut nodes = RootedVec::new();
         let nodes = if node.type_id() == NodeTypeId::DocumentFragment {
-            nodes.extend(node.children().map(|node| JS::from_rooted(&node)));
+            nodes.extend(node.children().map(|node| JS::from_ref(&*node)));
             nodes.r()
         } else {
             ref_slice(&node)

components/script/dom/nodelist.rs

@@ -43,7 +43,7 @@ impl NodeList {
 
     pub fn new_simple_list<T>(window: &Window, iter: T) -> Root<NodeList>
                               where T: Iterator<Item=Root<Node>> {
-        NodeList::new(window, NodeListType::Simple(iter.map(|r| JS::from_rooted(&r)).collect()))
+        NodeList::new(window, NodeListType::Simple(iter.map(|r| JS::from_ref(&*r)).collect()))
     }
 
     pub fn new_child_list(window: &Window, node: &Node) -> Root<NodeList> {

components/script/dom/performance.rs

@@ -26,7 +26,7 @@ impl Performance {
                      navigation_start_precise: f64) -> Performance {
         Performance {
             reflector_: Reflector::new(),
-            timing: JS::from_rooted(&PerformanceTiming::new(window,
+            timing: JS::from_ref(&*PerformanceTiming::new(window,
                                                             navigation_start,
                                                             navigation_start_precise)),
         }

components/script/dom/radionodelist.rs

@@ -38,7 +38,7 @@ impl RadioNodeList {
 
     pub fn new_simple_list<T>(window: &Window, iter: T) -> Root<RadioNodeList>
                               where T: Iterator<Item=Root<Node>> {
-        RadioNodeList::new(window, NodeListType::Simple(iter.map(|r| JS::from_rooted(&r)).collect()))
+        RadioNodeList::new(window, NodeListType::Simple(iter.map(|r| JS::from_ref(&*r)).collect()))
     }
 
     pub fn empty(window: &Window) -> Root<RadioNodeList> {

components/script/dom/xmlhttprequest.rs

@@ -157,7 +157,7 @@ impl XMLHttpRequest {
             ready_state: Cell::new(XMLHttpRequestState::Unsent),
             timeout: Cell::new(0u32),
             with_credentials: Cell::new(false),
-            upload: JS::from_rooted(&XMLHttpRequestUpload::new(global)),
+            upload: JS::from_ref(&*XMLHttpRequestUpload::new(global)),
             response_url: DOMRefCell::new(String::from("")),
             status: Cell::new(0),
             status_text: DOMRefCell::new(ByteString::new(vec!())),