Replaces uses of Vec<Root<T>>.

components/script/dom/domrectlist.rs

@@ -6,6 +6,7 @@ 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 +20,16 @@ pub struct DOMRectList {
 
 impl DOMRectList {
     fn new_inherited(window: JSRef<Window>,
-                         rects: Vec<JSRef<DOMRect>>) -> DOMRectList {
-        let rects = rects.iter().map(|rect| JS::from_rooted(*rect)).collect();
+                     rects: &RootedVec<JS<DOMRect>>) -> DOMRectList {
         DOMRectList {
             reflector_: Reflector::new(),
-            rects: rects,
+            rects: (**rects).clone(),
             window: JS::from_rooted(window),
         }
     }
 
     pub fn new(window: JSRef<Window>,
-               rects: Vec<JSRef<DOMRect>>) -> Temporary<DOMRectList> {
+               rects: &RootedVec<JS<DOMRect>>) -> Temporary<DOMRectList> {
         reflect_dom_object(box DOMRectList::new_inherited(window, rects),
                            GlobalRef::Window(window), DOMRectListBinding::Wrap)
     }

components/script/dom/element.rs

@@ -25,7 +25,8 @@ use dom::bindings::codegen::InheritTypes::HTMLAnchorElementCast;
 use dom::bindings::error::{ErrorResult, Fallible};
 use dom::bindings::error::Error::{NamespaceError, InvalidCharacter, Syntax};
 use dom::bindings::js::{MutNullableJS, JS, JSRef, LayoutJS, Temporary, TemporaryPushable};
-use dom::bindings::js::{OptionalRootable, Root};
+use dom::bindings::js::OptionalRootable;
+use dom::bindings::trace::RootedVec;
 use dom::bindings::utils::xml_name_type;
 use dom::bindings::utils::XMLName::{QName, Name, InvalidXMLName};
 use dom::create::create_element;
@@ -1061,17 +1062,18 @@ impl<'a> ElementMethods for JSRef<'a, Element> {
     fn GetClientRects(self) -> Temporary<DOMRectList> {
         let win = window_from_node(self).root();
         let node: JSRef<Node> = NodeCast::from_ref(self);
-        let rects = node.get_content_boxes();
-        let rects: Vec<Root<DOMRect>> = rects.iter().map(|r| {
-            DOMRect::new(
-                win.r(),
-                r.origin.y,
-                r.origin.y + r.size.height,
-                r.origin.x,
-                r.origin.x + r.size.width).root()
-        }).collect();
-
-        DOMRectList::new(win.r(), rects.iter().map(|rect| rect.r()).collect())
+        let raw_rects = node.get_content_boxes();
+        let mut rects = RootedVec::new();
+        for rect in raw_rects.iter() {
+            let rect = DOMRect::new(win.r(),
+                                    rect.origin.y,
+                                    rect.origin.y + rect.size.height,
+                                    rect.origin.x,
+                                    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/eventdispatcher.rs

@@ -4,8 +4,9 @@
 
 use dom::bindings::callback::ExceptionHandling::Report;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
-use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, NodeDerived};
-use dom::bindings::js::{JS, JSRef, OptionalRootable, Root};
+use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast};
+use dom::bindings::js::{JS, JSRef, OptionalRootable};
+use dom::bindings::trace::RootedVec;
 use dom::eventtarget::{EventTarget, ListenerPhase};
 use dom::event::{Event, EventPhase};
 use dom::node::{Node, NodeHelpers};
@@ -27,22 +28,21 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
     let type_ = event.Type();
 
     //TODO: no chain if not participating in a tree
-    let mut chain: Vec<Root<EventTarget>> = if target.is_node() {
-        let target_node: JSRef<Node> = NodeCast::to_ref(target).unwrap();
-        target_node.ancestors().map(|ancestor| {
+    let mut chain: RootedVec<JS<EventTarget>> = RootedVec::new();
+    if let Some(target_node) = NodeCast::to_ref(target) {
+        for ancestor in target_node.ancestors() {
             let ancestor_target: JSRef<EventTarget> = EventTargetCast::from_ref(ancestor);
-            JS::from_rooted(ancestor_target).root()
-        }).collect()
-    } else {
-        vec!()
-    };
+            chain.push(JS::from_rooted(ancestor_target))
+        }
+    }
 
     event.set_phase(EventPhase::Capturing);
 
     //FIXME: The "callback this value" should be currentTarget
 
     /* capturing */
     for cur_target in chain.as_slice().iter().rev() {
+        let cur_target = cur_target.root();
         let stopped = match cur_target.r().get_listeners_for(type_.as_slice(), ListenerPhase::Capturing) {
             Some(listeners) => {
                 event.set_current_target(cur_target.r());
@@ -88,6 +88,7 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
         event.set_phase(EventPhase::Bubbling);
 
         for cur_target in chain.iter() {
+            let cur_target = cur_target.root();
             let stopped = match cur_target.r().get_listeners_for(type_.as_slice(), ListenerPhase::Bubbling) {
                 Some(listeners) => {
                     event.set_current_target(cur_target.r());