Add DOMRefCell<T> for safe borrowing in layout.

This type simply wraps `RefCell<T>` to add the special method,
and introduce the method to return the pointer of the value contained in
itself, for used in layout task.

2 files changed, 69 insertions, 0 deletions

diff --git a/components/script/dom/bindings/cell.rs b/components/script/dom/bindings/cell.rs
new file mode 100644
index 00000000000..a4a15b7d5e7
--- /dev/null
+++ b/components/script/dom/bindings/cell.rs
@@ -0,0 +1,68 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use dom::bindings::trace::JSTraceable;
+use js::jsapi::{JSTracer};
+
+use std::cell;
+use std::cell::RefCell;
+use std::mem;
+
+/// A mutable field in DOM for large sized value.
+/// This has a special method to return the pointer of itself
+/// for used in layout task.
+/// This simply wraps `RefCell<T>` to add the special method.
+pub struct DOMRefCell<T> {
+    base: RefCell<T>,
+}
+
+pub type Ref<'a, T> = cell::Ref<'a, T>;
+pub type RefMut<'a, T> = cell::RefMut<'a, T>;
+
+
+impl<T> DOMRefCell<T> {
+    #[inline(always)]
+    pub fn new(value: T) -> DOMRefCell<T> {
+        DOMRefCell {
+            base: RefCell::new(value),
+        }
+    }
+
+    #[inline(always)]
+    pub fn unwrap(self) -> T {
+        self.base.unwrap()
+    }
+
+    #[inline(always)]
+    pub fn try_borrow<'a>(&'a self) -> Option<Ref<'a, T>> {
+        self.base.try_borrow()
+    }
+
+    #[inline(always)]
+    pub fn borrow<'a>(&'a self) -> Ref<'a, T> {
+        self.base.borrow()
+    }
+
+    #[inline(always)]
+    pub fn try_borrow_mut<'a>(&'a self) -> Option<RefMut<'a, T>> {
+        self.base.try_borrow_mut()
+    }
+
+    #[inline(always)]
+    pub fn borrow_mut<'a>(&'a self) -> RefMut<'a, T> {
+        self.base.borrow_mut()
+    }
+
+    /// This returns the pointer which refers T in `RefCell<T>` directly.
+    pub unsafe fn borrow_for_layout<'a>(&'a self) -> &'a T {
+        let val = mem::transmute::<&RefCell<T>, &T>(&self.base);
+        val
+    }
+}
+
+impl<T: JSTraceable> JSTraceable for DOMRefCell<T> {
+    fn trace(&self, trc: *mut JSTracer) {
+        (*self).base.borrow().trace(trc)
+    }
+}
diff --git a/components/script/lib.rs b/components/script/lib.rs
index 09bea1b73bd..03662371e0c 100644
--- a/components/script/lib.rs
+++ b/components/script/lib.rs
@@ -56,6 +56,7 @@ pub mod dom {
 
     /// The code to expose the DOM to JavaScript through IDL bindings.
     pub mod bindings {
+        pub mod cell;
         pub mod global;
         pub mod js;
         pub mod utils;