Auto merge of #6140 - nox:cleanup-rootedvec, r=Manishearth

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

components/script/dom/document.rs

@@ -1045,17 +1045,11 @@ trait PrivateDocumentHelpers {
 impl<'a> PrivateDocumentHelpers for JSRef<'a, Document> {
     fn create_node_list<F: Fn(JSRef<Node>) -> bool>(self, callback: F) -> Temporary<NodeList> {
         let window = self.window.root();
-        let document_element = self.GetDocumentElement().root();
+        let doc = self.GetDocumentElement().root();
-        let mut nodes = RootedVec::new();
+        let maybe_node = doc.r().map(NodeCast::from_ref);
-        if let Some(ref root) = document_element {
+        let iter = maybe_node.iter().flat_map(|node| node.traverse_preorder())
-            for node in NodeCast::from_ref(root.r()).traverse_preorder() {
+                             .filter(|node| callback(node.root().r()));
-                let node = node.root();
+        NodeList::new_simple_list(window.r(), iter)
-                if callback(node.r()) {
-                    nodes.push(JS::from_rooted(node.r()));
-                }
-            }
-        };
-        NodeList::new_simple_list(window.r(), &nodes)
     }
 
     fn get_html_element(self) -> Option<Temporary<HTMLHtmlElement>> {

components/script/dom/domrectlist.rs

@@ -6,7 +6,6 @@ use dom::bindings::codegen::Bindings::DOMRectListBinding;
 use dom::bindings::codegen::Bindings::DOMRectListBinding::DOMRectListMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, Temporary};
-use dom::bindings::trace::RootedVec;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::domrect::DOMRect;
 use dom::window::Window;
@@ -19,17 +18,17 @@ pub struct DOMRectList {
 }
 
 impl DOMRectList {
-    fn new_inherited(window: JSRef<Window>,
+    fn new_inherited<T>(window: JSRef<Window>, rects: T) -> DOMRectList
-                     rects: &RootedVec<JS<DOMRect>>) -> DOMRectList {
+                        where T: Iterator<Item=Temporary<DOMRect>> {
         DOMRectList {
             reflector_: Reflector::new(),
-            rects: (**rects).clone(),
+            rects: rects.map(JS::from_rooted).collect(),
             window: JS::from_rooted(window),
         }
     }
 
-    pub fn new(window: JSRef<Window>,
+    pub fn new<T>(window: JSRef<Window>, rects: T) -> Temporary<DOMRectList>
-               rects: &RootedVec<JS<DOMRect>>) -> Temporary<DOMRectList> {
+                  where T: Iterator<Item=Temporary<DOMRect>> {
         reflect_dom_object(box DOMRectList::new_inherited(window, rects),
                            GlobalRef::Window(window), DOMRectListBinding::Wrap)
     }

components/script/dom/element.rs

@@ -1301,17 +1301,12 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
         let win = window_from_node(self).root();
         let node: JSRef<Node> = NodeCast::from_ref(self);
         let raw_rects = node.get_content_boxes();
-        let mut rects = RootedVec::new();
+        let rects = raw_rects.iter().map(|rect| {
-        for rect in raw_rects.iter() {
+            DOMRect::new(win.r(),
-            let rect = DOMRect::new(win.r(),
+                         rect.origin.y, rect.origin.y + rect.size.height,
-                                    rect.origin.y,
+                         rect.origin.x, rect.origin.x + rect.size.width)
-                                    rect.origin.y + rect.size.height,
+        });
-                                    rect.origin.x,
+        DOMRectList::new(win.r(), rects)
-                                    rect.origin.x + rect.size.width);
-            rects.push(JS::from_rooted(rect));
-        }
-
-        DOMRectList::new(win.r(), &rects)
     }
 
     // http://dev.w3.org/csswg/cssom-view/#dom-element-getboundingclientrect

components/script/dom/node.rs

@@ -917,12 +917,9 @@ impl<'a> NodeHelpers for JSRef<'a, Node> {
     // https://dom.spec.whatwg.org/#dom-parentnode-queryselectorall
     #[allow(unsafe_code)]
     fn query_selector_all(self, selectors: DOMString) -> Fallible<Temporary<NodeList>> {
-        let mut nodes = RootedVec::new();
-        for node in try!(unsafe { self.query_selector_iter(selectors) }) {
-            nodes.push(JS::from_rooted(node));
-        }
         let window = window_from_node(self).root();
-        Ok(NodeList::new_simple_list(window.r(), &nodes))
+        let iter = try!(unsafe { self.query_selector_iter(selectors) });
+        Ok(NodeList::new_simple_list(window.r(), iter))
     }
 
 

components/script/dom/nodelist.rs

@@ -6,7 +6,6 @@ use dom::bindings::codegen::Bindings::NodeListBinding;
 use dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
 use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JS, JSRef, Rootable, Temporary};
-use dom::bindings::trace::RootedVec;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use dom::node::{Node, NodeHelpers};
 use dom::window::Window;
@@ -39,8 +38,10 @@ impl NodeList {
                            GlobalRef::Window(window), NodeListBinding::Wrap)
     }
 
-    pub fn new_simple_list(window: JSRef<Window>, elements: &RootedVec<JS<Node>>) -> Temporary<NodeList> {
+    pub fn new_simple_list<T>(window: JSRef<Window>, iter: T)
-        NodeList::new(window, NodeListType::Simple((**elements).clone()))
+                              -> Temporary<NodeList>
+                              where T: Iterator<Item=Temporary<Node>> {
+        NodeList::new(window, NodeListType::Simple(iter.map(JS::from_rooted).collect()))
     }
 
     pub fn new_child_list(window: JSRef<Window>, node: JSRef<Node>) -> Temporary<NodeList> {

components/script/script_task.rs

@@ -91,6 +91,7 @@ use std::any::Any;
 use std::borrow::ToOwned;
 use std::cell::{Cell, RefCell};
 use std::collections::HashSet;
+use std::mem;
 use std::option::Option;
 use std::ptr;
 use std::rc::Rc;
@@ -1395,11 +1396,12 @@ impl ScriptTask {
                 }
                 let page = get_page(&self.root_page(), pipeline_id);
                 let document = page.document().root();
+                // We temporarily steal the list of targets over which the mouse is to pass it to
+                // handle_mouse_move_event() in a safe RootedVec container.
                 let mut mouse_over_targets = RootedVec::new();
-                mouse_over_targets.append(&mut *self.mouse_over_targets.borrow_mut());
+                mem::swap(&mut *self.mouse_over_targets.borrow_mut(), &mut *mouse_over_targets);
-
                 document.r().handle_mouse_move_event(self.js_runtime.rt(), point, &mut mouse_over_targets);
-                *self.mouse_over_targets.borrow_mut() = mouse_over_targets.clone();
+                mem::swap(&mut *self.mouse_over_targets.borrow_mut(), &mut *mouse_over_targets);
             }
 
             KeyEvent(key, state, modifiers) => {