Use internal mutability for Event.

src/components/script/dom/customevent.rs

@@ -70,7 +70,7 @@ impl<'a> CustomEventMethods for JSRef<'a, CustomEvent> {
                        cancelable: bool,
                        detail: JSVal) {
         self.detail = Traceable::new(detail);
-        let event: &mut JSRef<Event> = EventCast::from_mut_ref(self);
+        let event: &JSRef<Event> = EventCast::from_ref(self);
         event.InitEvent(type_, can_bubble, cancelable);
     }
 }

src/components/script/dom/event.rs

@@ -4,14 +4,15 @@
 
 use dom::bindings::codegen::Bindings::EventBinding;
 use dom::bindings::codegen::Bindings::EventBinding::EventConstants;
-use dom::bindings::js::{JS, JSRef, Temporary};
-use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::bindings::error::Fallible;
+use dom::bindings::js::{JS, JSRef, Temporary};
+use dom::bindings::trace::Untraceable;
+use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
 use dom::eventtarget::EventTarget;
 use dom::window::Window;
 use servo_util::str::DOMString;
 use servo_util::geometry::PagePx;
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 
 use geom::point::Point2D;
 use geom::size::TypedSize2D;
@@ -51,16 +52,16 @@ pub struct Event {
     pub reflector_: Reflector,
     pub current_target: Cell<Option<JS<EventTarget>>>,
     pub target: Cell<Option<JS<EventTarget>>>,
-    pub type_: DOMString,
+    type_: Untraceable<RefCell<DOMString>>,
-    pub phase: EventPhase,
+    pub phase: Untraceable<Cell<EventPhase>>,
-    pub canceled: bool,
+    pub canceled: Untraceable<Cell<bool>>,
-    pub stop_propagation: bool,
+    pub stop_propagation: Untraceable<Cell<bool>>,
-    pub stop_immediate: bool,
+    pub stop_immediate: Untraceable<Cell<bool>>,
-    pub cancelable: bool,
+    pub cancelable: Untraceable<Cell<bool>>,
-    pub bubbles: bool,
+    pub bubbles: Untraceable<Cell<bool>>,
-    pub trusted: bool,
+    pub trusted: Untraceable<Cell<bool>>,
-    pub dispatching: bool,
+    pub dispatching: Untraceable<Cell<bool>>,
-    pub initialized: bool,
+    pub initialized: Untraceable<Cell<bool>>,
     pub timestamp: u64,
 }
 
@@ -71,16 +72,16 @@ impl Event {
             reflector_: Reflector::new(),
             current_target: Cell::new(None),
             target: Cell::new(None),
-            phase: PhaseNone,
+            phase: Untraceable::new(Cell::new(PhaseNone)),
-            type_: "".to_string(),
+            type_: Untraceable::new(RefCell::new("".to_string())),
-            canceled: false,
+            canceled: Untraceable::new(Cell::new(false)),
-            cancelable: true,
+            cancelable: Untraceable::new(Cell::new(true)),
-            bubbles: false,
+            bubbles: Untraceable::new(Cell::new(false)),
-            trusted: false,
+            trusted: Untraceable::new(Cell::new(false)),
-            dispatching: false,
+            dispatching: Untraceable::new(Cell::new(false)),
-            stop_propagation: false,
+            stop_propagation: Untraceable::new(Cell::new(false)),
-            stop_immediate: false,
+            stop_immediate: Untraceable::new(Cell::new(false)),
-            initialized: false,
+            initialized: Untraceable::new(Cell::new(false)),
             timestamp: time::get_time().sec as u64,
         }
     }
@@ -95,8 +96,8 @@ impl Event {
                type_: DOMString,
                can_bubble: bool,
                cancelable: bool) -> Temporary<Event> {
-        let mut event = Event::new_uninitialized(window).root();
+        let event = Event::new_uninitialized(window).root();
-        event.InitEvent(type_, can_bubble, cancelable);
+        event.deref().InitEvent(type_, can_bubble, cancelable);
         Temporary::from_rooted(&*event)
     }
 
@@ -113,23 +114,23 @@ pub trait EventMethods {
     fn GetTarget(&self) -> Option<Temporary<EventTarget>>;
     fn GetCurrentTarget(&self) -> Option<Temporary<EventTarget>>;
     fn DefaultPrevented(&self) -> bool;
-    fn PreventDefault(&mut self);
+    fn PreventDefault(&self);
-    fn StopPropagation(&mut self);
+    fn StopPropagation(&self);
-    fn StopImmediatePropagation(&mut self);
+    fn StopImmediatePropagation(&self);
     fn Bubbles(&self) -> bool;
     fn Cancelable(&self) -> bool;
     fn TimeStamp(&self) -> u64;
-    fn InitEvent(&mut self, type_: DOMString, bubbles: bool, cancelable: bool);
+    fn InitEvent(&self, type_: DOMString, bubbles: bool, cancelable: bool);
     fn IsTrusted(&self) -> bool;
 }
 
 impl<'a> EventMethods for JSRef<'a, Event> {
     fn EventPhase(&self) -> u16 {
-        self.phase as u16
+        self.phase.deref().get() as u16
     }
 
     fn Type(&self) -> DOMString {
-        self.type_.clone()
+        self.type_.deref().borrow().clone()
     }
 
     fn GetTarget(&self) -> Option<Temporary<EventTarget>> {
@@ -141,56 +142,56 @@ impl<'a> EventMethods for JSRef<'a, Event> {
     }
 
     fn DefaultPrevented(&self) -> bool {
-        self.canceled
+        self.canceled.deref().get()
     }
 
-    fn PreventDefault(&mut self) {
+    fn PreventDefault(&self) {
-        if self.cancelable {
+        if self.cancelable.deref().get() {
-            self.canceled = true
+            self.canceled.deref().set(true)
         }
     }
 
-    fn StopPropagation(&mut self) {
+    fn StopPropagation(&self) {
-        self.stop_propagation = true;
+        self.stop_propagation.deref().set(true);
     }
 
-    fn StopImmediatePropagation(&mut self) {
+    fn StopImmediatePropagation(&self) {
-        self.stop_immediate = true;
+        self.stop_immediate.deref().set(true);
-        self.stop_propagation = true;
+        self.stop_propagation.deref().set(true);
     }
 
     fn Bubbles(&self) -> bool {
-        self.bubbles
+        self.bubbles.deref().get()
     }
 
     fn Cancelable(&self) -> bool {
-        self.cancelable
+        self.cancelable.deref().get()
     }
 
     fn TimeStamp(&self) -> u64 {
         self.timestamp
     }
 
-    fn InitEvent(&mut self,
+    fn InitEvent(&self,
                  type_: DOMString,
                  bubbles: bool,
                  cancelable: bool) {
-        self.initialized = true;
+        self.initialized.deref().set(true);
-        if self.dispatching {
+        if self.dispatching.deref().get() {
             return;
         }
-        self.stop_propagation = false;
+        self.stop_propagation.deref().set(false);
-        self.stop_immediate = false;
+        self.stop_immediate.deref().set(false);
-        self.canceled = false;
+        self.canceled.deref().set(false);
-        self.trusted = false;
+        self.trusted.deref().set(false);
         self.target.set(None);
-        self.type_ = type_;
+        *self.type_.deref().borrow_mut() = type_;
-        self.bubbles = bubbles;
+        self.bubbles.deref().set(bubbles);
-        self.cancelable = cancelable;
+        self.cancelable.deref().set(cancelable);
     }
 
     fn IsTrusted(&self) -> bool {
-        self.trusted
+        self.trusted.deref().get()
     }
 }
 

src/components/script/dom/eventdispatcher.rs

@@ -13,19 +13,16 @@ use dom::virtualmethods::vtable_for;
 // See http://dom.spec.whatwg.org/#concept-event-dispatch for the full dispatch algorithm
 pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
                               pseudo_target: Option<JSRef<'b, EventTarget>>,
-                              event: &mut JSRef<Event>) -> bool {
+                              event: &JSRef<Event>) -> bool {
-    assert!(!event.deref().dispatching);
+    assert!(!event.deref().dispatching.deref().get());
 
-    {
+    event.target.assign(Some(match pseudo_target {
-        let event = event.deref_mut();
+        Some(pseudo_target) => pseudo_target,
-        event.target.assign(Some(match pseudo_target {
+        None => target.clone(),
-            Some(pseudo_target) => pseudo_target,
+    }));
-            None => target.clone(),
+    event.dispatching.deref().set(true);
-        }));
-        event.dispatching = true;
-    }
 
-    let type_ = event.deref().type_.clone();
+    let type_ = event.Type();
 
     //TODO: no chain if not participating in a tree
     let mut chain: Vec<Root<EventTarget>> = if target.deref().is_node() {
@@ -38,7 +35,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
         vec!()
     };
 
-    event.deref_mut().phase = PhaseCapturing;
+    event.deref().phase.deref().set(PhaseCapturing);
 
     //FIXME: The "callback this value" should be currentTarget
 
@@ -51,12 +48,12 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
                     // Explicitly drop any exception on the floor.
                     let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions);
 
-                    if event.deref().stop_immediate {
+                    if event.deref().stop_immediate.deref().get() {
                         break;
                     }
                 }
 
-                event.deref().stop_propagation
+                event.deref().stop_propagation.deref().get()
             }
             None => false
         };
@@ -67,12 +64,9 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
     }
 
     /* at target */
-    if !event.deref().stop_propagation {
+    if !event.deref().stop_propagation.deref().get() {
-        {
+        event.phase.deref().set(PhaseAtTarget);
-            let event = event.deref_mut();
+        event.current_target.assign(Some(target.clone()));
-            event.phase = PhaseAtTarget;
-            event.current_target.assign(Some(target.clone()));
-        }
 
         let opt_listeners = target.deref().get_listeners(type_.as_slice());
         for listeners in opt_listeners.iter() {
@@ -80,7 +74,7 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
                 // Explicitly drop any exception on the floor.
                 let _ = listener.HandleEvent_(target, event, ReportExceptions);
 
-                if event.deref().stop_immediate {
+                if event.deref().stop_immediate.deref().get() {
                     break;
                 }
             }
@@ -88,23 +82,23 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
     }
 
     /* bubbling */
-    if event.deref().bubbles && !event.deref().stop_propagation {
+    if event.deref().bubbles.deref().get() && !event.deref().stop_propagation.deref().get() {
-        event.deref_mut().phase = PhaseBubbling;
+        event.deref().phase.deref().set(PhaseBubbling);
 
         for cur_target in chain.iter() {
             let stopped = match cur_target.deref().get_listeners_for(type_.as_slice(), Bubbling) {
                 Some(listeners) => {
-                    event.deref_mut().current_target.assign(Some(cur_target.deref().clone()));
+                    event.deref().current_target.assign(Some(cur_target.deref().clone()));
                     for listener in listeners.iter() {
                         // Explicitly drop any exception on the floor.
                         let _ = listener.HandleEvent_(&**cur_target, event, ReportExceptions);
 
-                        if event.deref().stop_immediate {
+                        if event.deref().stop_immediate.deref().get() {
                             break;
                         }
                     }
 
-                    event.deref().stop_propagation
+                    event.deref().stop_propagation.deref().get()
                 }
                 None => false
             };
@@ -136,8 +130,8 @@ pub fn dispatch_event<'a, 'b>(target: &JSRef<'a, EventTarget>,
         let _ = chain.pop();
     }
 
-    event.dispatching = false;
+    event.dispatching.deref().set(false);
-    event.phase = PhaseNone;
+    event.phase.deref().set(PhaseNone);
     event.current_target.set(None);
 
     !event.DefaultPrevented()

src/components/script/dom/eventtarget.rs

@@ -89,7 +89,7 @@ impl EventTarget {
 pub trait EventTargetHelpers {
     fn dispatch_event_with_target<'a>(&self,
                                       target: Option<JSRef<'a, EventTarget>>,
-                                      event: &mut JSRef<Event>) -> Fallible<bool>;
+                                      event: &JSRef<Event>) -> Fallible<bool>;
     fn set_inline_event_listener(&mut self,
                                  ty: DOMString,
                                  listener: Option<EventListener>);
@@ -108,8 +108,8 @@ pub trait EventTargetHelpers {
 impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     fn dispatch_event_with_target<'b>(&self,
                                       target: Option<JSRef<'b, EventTarget>>,
-                                      event: &mut JSRef<Event>) -> Fallible<bool> {
+                                      event: &JSRef<Event>) -> Fallible<bool> {
-        if event.deref().dispatching || !event.deref().initialized {
+        if event.deref().dispatching.deref().get() || !event.deref().initialized.deref().get() {
             return Err(InvalidState);
         }
         Ok(dispatch_event(self, target, event))
@@ -210,7 +210,7 @@ pub trait EventTargetMethods {
                            ty: DOMString,
                            listener: Option<EventListener>,
                            capture: bool);
-    fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool>;
+    fn DispatchEvent(&self, event: &JSRef<Event>) -> Fallible<bool>;
 }
 
 impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
@@ -251,7 +251,7 @@ impl<'a> EventTargetMethods for JSRef<'a, EventTarget> {
         }
     }
 
-    fn DispatchEvent(&self, event: &mut JSRef<Event>) -> Fallible<bool> {
+    fn DispatchEvent(&self, event: &JSRef<Event>) -> Fallible<bool> {
         self.dispatch_event_with_target(None, event)
     }
 }

src/components/script/dom/progressevent.rs

@@ -37,13 +37,11 @@ impl ProgressEvent {
     pub fn new(window: &JSRef<Window>, type_: DOMString,
                can_bubble: bool, cancelable: bool,
                length_computable: bool, loaded: u64, total: u64) -> Temporary<ProgressEvent> {
-        let mut ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total),
+        let ev = reflect_dom_object(box ProgressEvent::new_inherited(length_computable, loaded, total),
-                                        window,
+                                    window,
-                                        ProgressEventBinding::Wrap).root();
+                                    ProgressEventBinding::Wrap).root();
-        {
+        let event: &JSRef<Event> = EventCast::from_ref(&*ev);
-            let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *ev);
+        event.InitEvent(type_, can_bubble, cancelable);
-            event.InitEvent(type_, can_bubble, cancelable);
-        }
         Temporary::from_rooted(&*ev)
     }
     pub fn Constructor(owner: &JSRef<Window>,

src/components/script/dom/uievent.rs

@@ -90,7 +90,7 @@ impl<'a> UIEventMethods for JSRef<'a, UIEvent> {
                    view: Option<JSRef<Window>>,
                    detail: i32) {
         {
-            let event: &mut JSRef<Event> = EventCast::from_mut_ref(self);
+            let event: &JSRef<Event> = EventCast::from_ref(self);
             event.InitEvent(type_, can_bubble, cancelable);
         }
         self.view.assign(view);

src/components/script/dom/xmlhttprequest.rs

@@ -638,10 +638,10 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
         assert!(self.ready_state != rs)
         self.ready_state = rs;
         let win = &*self.global.root();
-        let mut event =
+        let event =
             Event::new(win, "readystatechange".to_string(), false, true).root();
         let target: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
-        target.dispatch_event_with_target(None, &mut *event).ok();
+        target.dispatch_event_with_target(None, &*event).ok();
     }
 
     fn process_partial_response(&mut self, progress: XHRProgress) {
@@ -739,16 +739,16 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
     fn dispatch_progress_event(&self, upload: bool, type_: DOMString, loaded: u64, total: Option<u64>) {
         let win = &*self.global.root();
         let upload_target = &*self.upload.get().root().unwrap();
-        let mut progressevent = ProgressEvent::new(win, type_, false, false,
+        let progressevent = ProgressEvent::new(win, type_, false, false,
-                                                   total.is_some(), loaded,
+                                               total.is_some(), loaded,
-                                                   total.unwrap_or(0)).root();
+                                               total.unwrap_or(0)).root();
         let target: &JSRef<EventTarget> = if upload {
             EventTargetCast::from_ref(upload_target)
         } else {
             EventTargetCast::from_ref(self)
         };
-        let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *progressevent);
+        let event: &JSRef<Event> = EventCast::from_ref(&*progressevent);
-        target.dispatch_event_with_target(None, &mut *event).ok();
+        target.dispatch_event_with_target(None, event).ok();
     }
 
     fn dispatch_upload_progress_event(&self, type_: DOMString, partial_load: Option<u64>) {

src/components/script/script_task.rs

@@ -1033,12 +1033,11 @@ impl ScriptTask {
         // We have no concept of a document loader right now, so just dispatch the
         // "load" event as soon as we've finished executing all scripts parsed during
         // the initial load.
-        let mut event =
+        let event = Event::new(&*window, "load".to_string(), false, false).root();
-            Event::new(&*window, "load".to_string(), false, false).root();
         let doctarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*document);
         let wintarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&*window);
         let _ = wintarget.dispatch_event_with_target(Some((*doctarget).clone()),
-                                                     &mut *event);
+                                                     &*event);
 
         page.fragment_node.assign(fragment.map_or(None, |fragid| page.find_fragment_node(fragid)));
 
@@ -1089,12 +1088,14 @@ impl ScriptTask {
                     Some(mut window) => {
                         // http://dev.w3.org/csswg/cssom-view/#resizing-viewports
                         // https://dvcs.w3.org/hg/dom3events/raw-file/tip/html/DOM3-Events.html#event-type-resize
-                        let mut uievent = UIEvent::new(&window.clone(), "resize".to_string(), false, false,
+                        let uievent = UIEvent::new(&window.clone(),
-                                                       Some((*window).clone()), 0i32).root();
+                                                   "resize".to_string(), false,
-                        let event: &mut JSRef<Event> = EventCast::from_mut_ref(&mut *uievent);
+                                                   false, Some(window.clone()),
+                                                   0i32).root();
+                        let event: &JSRef<Event> = EventCast::from_ref(&*uievent);
 
                         let wintarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(&mut *window);
-                        let _ = wintarget.dispatch_event_with_target(None, &mut *event);
+                        let _ = wintarget.dispatch_event_with_target(None, event);
                     }
                     None => ()
                 }
@@ -1129,12 +1130,12 @@ impl ScriptTask {
                                 match *page.frame() {
                                     Some(ref frame) => {
                                         let window = frame.window.root();
-                                        let mut event =
+                                        let event =
                                             Event::new(&*window,
                                                        "click".to_string(),
                                                        true, true).root();
                                         let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&node);
-                                        let _ = eventtarget.dispatch_event_with_target(None, &mut *event);
+                                        let _ = eventtarget.dispatch_event_with_target(None, &*event);
                                     }
                                     None => {}
                                 }