Rename Root<T> to DomRoot<T>

In a later PR, DomRoot<T> will become a type alias of Root<Dom<T>>,
where Root<T> will be able to handle all the things that need to be
rooted that have a stable traceable address that doesn't move for the
whole lifetime of the root. Stay tuned.

1 files changed, 14 insertions, 14 deletions

diff --git a/components/script/dom/domquad.rs b/components/script/dom/domquad.rs
index f31cfc3e05e..54c07b8275c 100644
--- a/components/script/dom/domquad.rs
+++ b/components/script/dom/domquad.rs
@@ -7,7 +7,7 @@ use dom::bindings::codegen::Bindings::DOMQuadBinding::{DOMQuadInit, DOMQuadMetho
 use dom::bindings::codegen::Bindings::DOMRectReadOnlyBinding::DOMRectInit;
 use dom::bindings::error::Fallible;
 use dom::bindings::reflector::{DomObject, Reflector, reflect_dom_object};
-use dom::bindings::root::{Root, Dom};
+use dom::bindings::root::{Dom, DomRoot};
 use dom::dompoint::DOMPoint;
 use dom::domrect::DOMRect;
 use dom::globalscope::GlobalScope;
@@ -42,7 +42,7 @@ impl DOMQuad {
                p1: &DOMPoint,
                p2: &DOMPoint,
                p3: &DOMPoint,
-               p4: &DOMPoint) -> Root<DOMQuad> {
+               p4: &DOMPoint) -> DomRoot<DOMQuad> {
         reflect_dom_object(box DOMQuad::new_inherited(p1, p2, p3, p4),
                            global,
                            Wrap)
@@ -53,7 +53,7 @@ impl DOMQuad {
                        p2: &DOMPointInit,
                        p3: &DOMPointInit,
                        p4: &DOMPointInit)
-                       -> Fallible<Root<DOMQuad>> {
+                       -> Fallible<DomRoot<DOMQuad>> {
         Ok(DOMQuad::new(global,
                         &*DOMPoint::new_from_init(global, p1),
                         &*DOMPoint::new_from_init(global, p2),
@@ -62,7 +62,7 @@ impl DOMQuad {
     }
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-fromrect
-    pub fn FromRect(global: &GlobalScope, other: &DOMRectInit) -> Root<DOMQuad> {
+    pub fn FromRect(global: &GlobalScope, other: &DOMRectInit) -> DomRoot<DOMQuad> {
         DOMQuad::new(global,
                      &*DOMPoint::new(global, other.x, other.y, 0f64, 1f64),
                      &*DOMPoint::new(global, other.x + other.width, other.y, 0f64, 1f64),
@@ -71,7 +71,7 @@ impl DOMQuad {
     }
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-fromquad
-    pub fn FromQuad(global: &GlobalScope, other: &DOMQuadInit) -> Root<DOMQuad> {
+    pub fn FromQuad(global: &GlobalScope, other: &DOMQuadInit) -> DomRoot<DOMQuad> {
         DOMQuad::new(global,
                      &DOMPoint::new_from_init(global, &other.p1),
                      &DOMPoint::new_from_init(global, &other.p2),
@@ -82,27 +82,27 @@ impl DOMQuad {
 
 impl DOMQuadMethods for DOMQuad {
     // https://drafts.fxtf.org/geometry/#dom-domquad-p1
-    fn P1(&self) -> Root<DOMPoint> {
-        Root::from_ref(&self.p1)
+    fn P1(&self) -> DomRoot<DOMPoint> {
+        DomRoot::from_ref(&self.p1)
     }
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-p2
-    fn P2(&self) -> Root<DOMPoint> {
-        Root::from_ref(&self.p2)
+    fn P2(&self) -> DomRoot<DOMPoint> {
+        DomRoot::from_ref(&self.p2)
     }
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-p3
-    fn P3(&self) -> Root<DOMPoint> {
-        Root::from_ref(&self.p3)
+    fn P3(&self) -> DomRoot<DOMPoint> {
+        DomRoot::from_ref(&self.p3)
     }
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-p4
-    fn P4(&self) -> Root<DOMPoint> {
-        Root::from_ref(&self.p4)
+    fn P4(&self) -> DomRoot<DOMPoint> {
+        DomRoot::from_ref(&self.p4)
     }
 
     // https://drafts.fxtf.org/geometry/#dom-domquad-getbounds
-    fn GetBounds(&self) -> Root<DOMRect> {
+    fn GetBounds(&self) -> DomRoot<DOMRect> {
         let left = self.p1.X().min(self.p2.X()).min(self.p3.X()).min(self.p4.X());
         let top = self.p1.Y().min(self.p2.Y()).min(self.p3.Y()).min(self.p4.Y());
         let right = self.p1.X().max(self.p2.X()).max(self.p3.X()).max(self.p4.X());