Use Heap<T>

components/script/dom/bindings/callback.rs

@@ -9,7 +9,7 @@ use dom::bindings::js::JSRef;
 use dom::bindings::utils::Reflectable;
 use js::jsapi::{JSContext, JSObject, JS_WrapObject, IsCallable};
 use js::jsapi::{JS_GetProperty, JS_IsExceptionPending, JS_ReportPendingException};
-use js::jsapi::{RootedObject, RootedValue};
+use js::jsapi::{RootedObject, RootedValue, Heap};
 use js::jsapi::{JSAutoCompartment};
 use js::jsapi::{JS_BeginRequest, JS_EndRequest};
 use js::jsapi::{JS_EnterCompartment, JS_LeaveCompartment, JSCompartment};
@@ -41,7 +41,7 @@ impl CallbackFunction {
     pub fn new(callback: *mut JSObject) -> CallbackFunction {
         CallbackFunction {
             object: CallbackObject {
-                callback: callback
+                callback: Heap::<*mut JSObject>::new(callback)
             }
         }
     }
@@ -57,11 +57,11 @@ pub struct CallbackInterface {
 /// A common base class for representing IDL callback function and
 /// callback interface types.
 #[allow(raw_pointer_derive)]
-#[derive(Copy, Clone,PartialEq)]
+#[derive(Copy, Clone, PartialEq)]
 #[jstraceable]
 struct CallbackObject {
     /// The underlying `JSObject`.
-    callback: *mut JSObject,
+    callback: Heap<*mut JSObject>,
 }
 
 /// A trait to be implemented by concrete IDL callback function and
@@ -76,14 +76,14 @@ pub trait CallbackContainer {
 impl CallbackInterface {
     /// Returns the underlying `JSObject`.
     pub fn callback(&self) -> *mut JSObject {
-        self.object.callback
+        self.object.callback.ptr
     }
 }
 
 impl CallbackFunction {
     /// Returns the underlying `JSObject`.
     pub fn callback(&self) -> *mut JSObject {
-        self.object.callback
+        self.object.callback.ptr
     }
 }
 
@@ -92,7 +92,7 @@ impl CallbackInterface {
     pub fn new(callback: *mut JSObject) -> CallbackInterface {
         CallbackInterface {
             object: CallbackObject {
-                callback: callback
+                callback: Heap::<*mut JSObject>::new(callback)
             }
         }
     }

components/script/dom/bindings/js.rs

@@ -54,7 +54,7 @@ use dom::bindings::trace::JSTraceable;
 use dom::bindings::trace::RootedVec;
 use dom::bindings::utils::{Reflector, Reflectable};
 use dom::node::Node;
-use js::jsapi::JSObject;
+use js::jsapi::{JSObject, Heap};
 use js::jsval::JSVal;
 use layout_interface::TrustedNodeAddress;
 use script_task::STACK_ROOTS;
@@ -298,7 +298,7 @@ impl<T: Reflectable> Reflectable for JS<T> {
 pub trait HeapGCValue: JSTraceable {
 }
 
-impl HeapGCValue for JSVal {
+impl HeapGCValue for Heap<JSVal> {
 }
 
 impl<T: Reflectable> HeapGCValue for JS<T> {

components/script/dom/bindings/trace.rs

@@ -171,7 +171,7 @@ impl<T: JSTraceable+Copy> JSTraceable for Cell<T> {
 }
 
 
-impl JSTraceable for *mut JSObject {
+impl JSTraceable for Heap<*mut JSObject> {
     fn trace(&self, trc: *mut JSTracer) {
         unsafe {
             trace_object(trc, "object", mem::transmute(&*self));
@@ -180,7 +180,7 @@ impl JSTraceable for *mut JSObject {
 }
 
 
-impl JSTraceable for JSVal {
+impl JSTraceable for Heap<JSVal> {
     fn trace(&self, trc: *mut JSTracer) {
         unsafe {
             trace_jsval(trc, "val", mem::transmute(&*self));
@@ -394,8 +394,8 @@ impl RootedCollectionSet {
             }
         }
 
-        trace_collection_type::<JSVal>(tracer, &self.set[CollectionType::JSVals as usize]);
-        trace_collection_type::<*mut JSObject>(tracer, &self.set[CollectionType::JSObjects as usize]);
+//        trace_collection_type::<JSVal>(tracer, &self.set[CollectionType::JSVals as usize]);
+//        trace_collection_type::<*mut JSObject>(tracer, &self.set[CollectionType::JSObjects as usize]);
     }
 }
 

components/script/dom/bindings/utils.rs

@@ -403,7 +403,7 @@ impl Reflector {
         assert!(self.object.get().ptr.is_null());
         assert!(!object.is_null());
         unsafe {
-            let mut cell = self.object.as_unsafe_cell().get();
+            let cell = self.object.as_unsafe_cell().get();
             (*cell).set(object);
         }
     }
@@ -418,7 +418,7 @@ impl Reflector {
     /// Create an uninitialized `Reflector`.
     pub fn new() -> Reflector {
         Reflector {
-            object: Cell::default()
+            object: Cell::new(Heap { ptr: ptr::null_mut() })
         }
     }
 }

components/script/dom/browsercontext.rs

@@ -19,7 +19,7 @@ use js::jsapi::{JSContext, JSObject, JSPropertyDescriptor, JSErrNum};
 use js::jsapi::{HandleObject, HandleId, MutableHandle, MutableHandleValue};
 use js::jsapi::{JS_AlreadyHasOwnPropertyById, JS_ForwardGetPropertyTo};
 use js::jsapi::{JS_GetPropertyDescriptorById, JS_DefinePropertyById6};
-use js::jsapi::{JS_ForwardSetPropertyTo, ObjectOpResult, RootedObject, RootedValue, Handle, HandleValue};
+use js::jsapi::{JS_ForwardSetPropertyTo, ObjectOpResult, RootedObject, RootedValue, Handle, HandleValue, Heap};
 use js::jsapi::{JSAutoRequest, JSAutoCompartment};
 use js::jsval::ObjectValue;
 use js::glue::{GetProxyPrivate};
@@ -33,7 +33,7 @@ use std::ptr;
 pub struct BrowserContext {
     history: Vec<SessionHistoryEntry>,
     active_index: usize,
-    window_proxy: *mut JSObject,
+    window_proxy: Heap<*mut JSObject>,
     frame_element: Option<JS<Element>>,
 }
 
@@ -42,7 +42,7 @@ impl BrowserContext {
         let mut context = BrowserContext {
             history: vec!(SessionHistoryEntry::new(document)),
             active_index: 0,
-            window_proxy: ptr::null_mut(),
+            window_proxy: Heap { ptr: ptr::null_mut() },
             frame_element: frame_element.map(JS::from_rooted),
         };
         context.create_window_proxy();
@@ -63,8 +63,8 @@ impl BrowserContext {
     }
 
     pub fn window_proxy(&self) -> *mut JSObject {
-        assert!(!self.window_proxy.is_null());
-        self.window_proxy
+        assert!(!self.window_proxy.ptr.is_null());
+        self.window_proxy.ptr
     }
 
     #[allow(unsafe_code)]
@@ -81,7 +81,7 @@ impl BrowserContext {
         let _ac = JSAutoCompartment::new(cx, parent.ptr);
         let wrapper = unsafe { WrapperNew(cx, parent.handle(), handler) };
         assert!(!wrapper.is_null());
-        self.window_proxy = wrapper;
+        self.window_proxy.set(wrapper);
     }
 }
 

components/script/dom/customevent.rs

@@ -8,18 +8,19 @@ use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::InheritTypes::{EventCast, CustomEventDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{JSRef, MutHeap, Rootable, Temporary};
+use dom::bindings::js::{JSRef, Rootable, Temporary};
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId};
-use js::jsapi::{JSContext, HandleValue};
+use js::jsapi::{JSContext, HandleValue, Heap};
 use js::jsval::{JSVal, NullValue};
 use util::str::DOMString;
+use std::cell::Cell;
 
 // https://dom.spec.whatwg.org/#interface-customevent
 #[dom_struct]
 pub struct CustomEvent {
     event: Event,
-    detail: MutHeap<JSVal>,
+    detail: Cell<Heap<JSVal>>,
 }
 
 impl CustomEventDerived for Event {
@@ -32,7 +33,7 @@ impl CustomEvent {
     fn new_inherited(type_id: EventTypeId) -> CustomEvent {
         CustomEvent {
             event: Event::new_inherited(type_id),
-            detail: MutHeap::new(NullValue()),
+            detail: Cell::new(Heap::new(NullValue())),
         }
     }
 
@@ -56,10 +57,11 @@ impl CustomEvent {
 impl<'a> CustomEventMethods for JSRef<'a, CustomEvent> {
     // https://dom.spec.whatwg.org/#dom-customevent-detail
     fn Detail(self, _cx: *mut JSContext) -> JSVal {
-        self.detail.get()
+        self.detail.get().get()
     }
 
     // https://dom.spec.whatwg.org/#dom-customevent-initcustomevent
+    #[allow(unsafe_code)]
     fn InitCustomEvent(self,
                        _cx: *mut JSContext,
                        type_: DOMString,
@@ -71,7 +73,10 @@ impl<'a> CustomEventMethods for JSRef<'a, CustomEvent> {
             return;
         }
 
-        self.detail.set(detail.get());
+        unsafe {
+            let cell = self.detail.as_unsafe_cell().get();
+            (*cell).set(detail.get());
+        }
         event.InitEvent(type_, can_bubble, cancelable);
     }
 }

components/script/dom/errorevent.rs

@@ -8,8 +8,8 @@ use dom::bindings::codegen::Bindings::ErrorEventBinding::ErrorEventMethods;
 use dom::bindings::codegen::InheritTypes::{EventCast, ErrorEventDerived};
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{JSRef, MutHeap, Rootable, Temporary};
-use js::jsapi::{JSContext, HandleValue};
+use dom::bindings::js::{JSRef, Rootable, Temporary};
+use js::jsapi::{JSContext, HandleValue, Heap};
 use dom::bindings::trace::JSTraceable;
 
 use dom::bindings::utils::reflect_dom_object;
@@ -28,7 +28,7 @@ pub struct ErrorEvent {
     filename: DOMRefCell<DOMString>,
     lineno: Cell<u32>,
     colno: Cell<u32>,
-    error: MutHeap<JSVal>,
+    error: Cell<Heap<JSVal>>,
 }
 
 impl ErrorEventDerived for Event {
@@ -45,7 +45,7 @@ impl ErrorEvent {
             filename: DOMRefCell::new("".to_owned()),
             lineno: Cell::new(0),
             colno: Cell::new(0),
-            error: MutHeap::new(NullValue())
+            error: Cell::new(Heap::new(NullValue()))
         }
     }
 
@@ -55,6 +55,7 @@ impl ErrorEvent {
                            ErrorEventBinding::Wrap)
     }
 
+    #[allow(unsafe_code)]
     pub fn new(global: GlobalRef,
                type_: DOMString,
                bubbles: EventBubbles,
@@ -74,7 +75,10 @@ impl ErrorEvent {
         *ev.filename.borrow_mut() = filename;
         ev.lineno.set(lineno);
         ev.colno.set(colno);
-        ev.error.set(error.get());
+        unsafe {
+            let cell = ev.error.as_unsafe_cell().get();
+            (*cell).set(error.get());
+        }
         Temporary::from_rooted(ev)
     }
 
@@ -130,7 +134,7 @@ impl<'a> ErrorEventMethods for JSRef<'a, ErrorEvent> {
     }
 
     fn Error(self, _cx: *mut JSContext) -> JSVal {
-        self.error.get()
+        self.error.get().get()
     }
 
 }

components/script/dom/imagedata.rs

@@ -8,7 +8,7 @@ use dom::bindings::global::GlobalRef;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflector, reflect_dom_object};
 use geom::size::Size2D;
-use js::jsapi::{JSContext, JSObject};
+use js::jsapi::{JSContext, JSObject, Heap};
 use js::jsapi::{JS_NewUint8ClampedArray, JS_GetUint8ClampedArrayData};
 use libc::uint8_t;
 use std::vec::Vec;
@@ -21,7 +21,7 @@ pub struct ImageData {
     reflector_: Reflector,
     width: u32,
     height: u32,
-    data: *mut JSObject,
+    data: Heap<*mut JSObject>,
 }
 
 impl ImageData {
@@ -40,7 +40,7 @@ impl ImageData {
                 reflector_: Reflector::new(),
                 width: width,
                 height: height,
-                data: js_object,
+                data: Heap::new(js_object),
             }
         }
     }
@@ -85,6 +85,6 @@ impl<'a> ImageDataMethods for JSRef<'a, ImageData> {
 
     // https://html.spec.whatwg.org/multipage/#dom-imagedata-data
     fn Data(self, _: *mut JSContext) -> *mut JSObject {
-        self.data
+        self.data.ptr
     }
 }

components/script/dom/messageevent.rs

@@ -15,15 +15,15 @@ use dom::eventtarget::EventTarget;
 
 use util::str::DOMString;
 
-use js::jsapi::JSContext;
+use js::jsapi::{JSContext, Heap};
 use js::jsval::{JSVal, UndefinedValue};
 
 use std::borrow::ToOwned;
 
 #[dom_struct]
 pub struct MessageEvent {
     event: Event,
-    data: JSVal,
+    data: Heap<JSVal>,
     origin: DOMString,
     lastEventId: DOMString,
 }
@@ -39,7 +39,7 @@ impl MessageEvent {
                          -> MessageEvent {
         MessageEvent {
             event: Event::new_inherited(EventTypeId::MessageEvent),
-            data: data,
+            data: Heap::<JSVal>::new(data),
             origin: origin,
             lastEventId: lastEventId,
         }
@@ -89,7 +89,7 @@ impl MessageEvent {
 
 impl<'a> MessageEventMethods for JSRef<'a, MessageEvent> {
     fn Data(self, _cx: *mut JSContext) -> JSVal {
-        self.data
+        self.data.get()
     }
 
     fn Origin(self) -> DOMString {

components/script/timers.rs

@@ -17,7 +17,7 @@ use horribly_inefficient_timers;
 use util::task::spawn_named;
 use util::str::DOMString;
 
-use js::jsapi::{RootedValue, HandleValue};
+use js::jsapi::{RootedValue, HandleValue, Heap};
 use js::jsval::{JSVal, UndefinedValue};
 
 use std::borrow::ToOwned;
@@ -110,7 +110,7 @@ pub enum TimerControlMsg {
 struct TimerData {
     is_interval: IsInterval,
     callback: TimerCallback,
-    args: Vec<JSVal>
+    args: Vec<Heap<JSVal>>
 }
 
 impl TimerManager {
@@ -207,7 +207,7 @@ impl TimerManager {
             data: TimerData {
                 is_interval: is_interval,
                 callback: callback,
-                args: arguments.iter().map(|arg| arg.get()).collect()
+                args: arguments.iter().map(|arg| Heap::new(arg.get())).collect()
             }
         };
         self.active_timers.borrow_mut().insert(timer_id, timer);
@@ -232,7 +232,7 @@ impl TimerManager {
         // TODO: Must handle rooting of funval and args when movable GC is turned on
         match data.callback {
             TimerCallback::FunctionTimerCallback(function) => {
-                let args = data.args.iter().map(|arg| HandleValue { ptr: arg }).collect();
+                let args = data.args.iter().map(|arg| HandleValue { ptr: &arg.ptr }).collect();
                 let _ = function.Call_(this, args, Report);
             }
             TimerCallback::StringTimerCallback(code_str) => {