Rename Root::root_ref() to Root::r().

As it will be used much more widely after the upcoming changes, this limits
the effort reading and writing the method calls.

components/script/dom/bindings/codegen/CodegenRust.py

@@ -2307,7 +2307,7 @@ class CGPerSignatureCall(CGThing):
         def process(arg, i):
             argVal = "arg" + str(i)
             if arg.type.isGeckoInterface() and not arg.type.unroll().inner.isCallback():
-                argVal += ".root_ref()"
+                argVal += ".r()"
             return argVal
         return [(a, process(a, i)) for (i, a) in enumerate(self.arguments)]
 
@@ -3540,7 +3540,7 @@ class CGProxySpecialOperation(CGPerSignatureCall):
         def process(arg):
             argVal = arg.identifier.name
             if arg.type.isGeckoInterface() and not arg.type.unroll().inner.isCallback():
-                argVal += ".root_ref()"
+                argVal += ".r()"
             return argVal
         args = [(a, process(a)) for a in self.arguments]
         if self.idlNode.isGetter():

components/script/dom/bindings/global.rs

@@ -103,8 +103,8 @@ impl GlobalRoot {
     /// lifetime of this root.
     pub fn root_ref<'c>(&'c self) -> GlobalRef<'c> {
         match *self {
-            GlobalRoot::Window(ref window) => GlobalRef::Window(window.root_ref()),
-            GlobalRoot::Worker(ref worker) => GlobalRef::Worker(worker.root_ref()),
+            GlobalRoot::Window(ref window) => GlobalRef::Window(window.r()),
+            GlobalRoot::Worker(ref worker) => GlobalRef::Worker(worker.r()),
         }
     }
 }

components/script/dom/bindings/js.rs

@@ -31,11 +31,11 @@
 //! Both `Temporary<T>` and `JS<T>` do not allow access to their inner value without explicitly
 //! creating a stack-based root via the `root` method. This returns a `Root<T>`, which causes
 //! the JS-owned value to be uncollectable for the duration of the `Root` object's lifetime.
-//! A `JSRef<T>` can be obtained from a `Root<T>` either by dereferencing the `Root<T>` (`*rooted`)
-//! or explicitly calling the `root_ref` method. These `JSRef<T>` values are not allowed to
-//! outlive their originating `Root<T>`, to ensure that all interactions with the enclosed value
-//! only occur when said value is uncollectable, and will cause static lifetime errors if
-//! misused.
+//! A `JSRef<T>` can be obtained from a `Root<T>` by calling the `r` method. (Dereferencing the
+//! object is still supported, but as it is unsafe, this is deprecated.) These `JSRef<T>` values
+//! are not allowed to outlive their originating `Root<T>`, to ensure that all interactions with
+//! the enclosed value only occur when said value is uncollectable, and will cause static lifetime
+//! errors if misused.
 //!
 //! Other miscellaneous helper traits:
 //!
@@ -307,23 +307,23 @@ impl<From, To> JS<From> {
 
 /// Get an `Option<JSRef<T>>` out of an `Option<Root<T>>`
 pub trait RootedReference<T> {
-    fn root_ref<'a>(&'a self) -> Option<JSRef<'a, T>>;
+    fn r<'a>(&'a self) -> Option<JSRef<'a, T>>;
 }
 
 impl<T: Reflectable> RootedReference<T> for Option<Root<T>> {
-    fn root_ref<'a>(&'a self) -> Option<JSRef<'a, T>> {
-        self.as_ref().map(|root| root.root_ref())
+    fn r<'a>(&'a self) -> Option<JSRef<'a, T>> {
+        self.as_ref().map(|root| root.r())
     }
 }
 
 /// Get an `Option<Option<JSRef<T>>>` out of an `Option<Option<Root<T>>>`
 pub trait OptionalRootedReference<T> {
-    fn root_ref<'a>(&'a self) -> Option<Option<JSRef<'a, T>>>;
+    fn r<'a>(&'a self) -> Option<Option<JSRef<'a, T>>>;
 }
 
 impl<T: Reflectable> OptionalRootedReference<T> for Option<Option<Root<T>>> {
-    fn root_ref<'a>(&'a self) -> Option<Option<JSRef<'a, T>>> {
-        self.as_ref().map(|inner| inner.root_ref())
+    fn r<'a>(&'a self) -> Option<Option<JSRef<'a, T>>> {
+        self.as_ref().map(|inner| inner.r())
     }
 }
 
@@ -513,7 +513,7 @@ impl<T: Reflectable> Root<T> {
 
     /// Obtain a safe reference to the wrapped JS owned-value that cannot outlive
     /// the lifetime of this root.
-    pub fn root_ref<'b>(&'b self) -> JSRef<'b,T> {
+    pub fn r<'b>(&'b self) -> JSRef<'b, T> {
         self.jsref.clone()
     }
 }