Privatize Event

components/script/dom/customevent.rs

@@ -27,7 +27,7 @@ pub struct CustomEvent {
 
 impl CustomEventDerived for Event {
     fn is_customevent(&self) -> bool {
-        self.type_id == CustomEventTypeId
+        *self.type_id() == CustomEventTypeId
     }
 }
 

components/script/dom/event.rs

@@ -37,21 +37,22 @@ pub enum EventTypeId {
 
 #[jstraceable]
 #[must_root]
+#[privatize]
 pub struct Event {
-    pub type_id: EventTypeId,
+    type_id: EventTypeId,
     reflector_: Reflector,
-    pub current_target: MutNullableJS<EventTarget>,
-    pub target: MutNullableJS<EventTarget>,
+    current_target: MutNullableJS<EventTarget>,
+    target: MutNullableJS<EventTarget>,
     type_: RefCell<DOMString>,
-    pub phase: Cell<EventPhase>,
-    pub canceled: Cell<bool>,
-    pub stop_propagation: Cell<bool>,
-    pub stop_immediate: Cell<bool>,
-    pub cancelable: Cell<bool>,
-    pub bubbles: Cell<bool>,
-    pub trusted: Cell<bool>,
-    pub dispatching: Cell<bool>,
-    pub initialized: Cell<bool>,
+    phase: Cell<EventPhase>,
+    canceled: Cell<bool>,
+    stop_propagation: Cell<bool>,
+    stop_immediate: Cell<bool>,
+    cancelable: Cell<bool>,
+    bubbles: Cell<bool>,
+    trusted: Cell<bool>,
+    dispatching: Cell<bool>,
+    initialized: Cell<bool>,
     timestamp: u64,
 }
 
@@ -96,6 +97,61 @@ impl Event {
                        init: &EventBinding::EventInit) -> Fallible<Temporary<Event>> {
         Ok(Event::new(global, type_, init.bubbles, init.cancelable))
     }
+
+    #[inline]
+    pub fn type_id<'a>(&'a self) -> &'a EventTypeId {
+        &self.type_id
+    }
+
+    #[inline]
+    pub fn clear_current_target(&self) {
+        self.current_target.clear();
+    }
+
+    #[inline]
+    pub fn set_current_target(&self, val: JSRef<EventTarget>) {
+        self.current_target.assign(Some(val));
+    }
+
+    #[inline]
+    pub fn set_target(&self, val: JSRef<EventTarget>) {
+        self.target.assign(Some(val));
+    }
+
+    #[inline]
+    pub fn set_phase(&self, val: EventPhase) {
+        self.phase.set(val)
+    }
+
+    #[inline]
+    pub fn stop_propagation(&self) -> bool {
+        self.stop_propagation.get()
+    }
+
+    #[inline]
+    pub fn stop_immediate(&self) -> bool {
+        self.stop_immediate.get()
+    }
+
+    #[inline]
+    pub fn bubbles(&self) -> bool {
+        self.bubbles.get()
+    }
+
+    #[inline]
+    pub fn dispatching(&self) -> bool {
+        self.dispatching.get()
+    }
+
+    #[inline]
+    pub fn set_dispatching(&self, val: bool) {
+        self.dispatching.set(val)
+    }
+
+    #[inline]
+    pub fn initialized(&self) -> bool {
+        self.initialized.get()
+    }
 }
 
 impl<'a> EventMethods for JSRef<'a, Event> {

components/script/dom/eventdispatcher.rs

@@ -5,7 +5,7 @@
 use dom::bindings::callback::ReportExceptions;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast, NodeDerived};
-use dom::bindings::js::{JS, JSRef, OptionalSettable, OptionalRootable, Root};
+use dom::bindings::js::{JS, JSRef, OptionalRootable, Root};
 use dom::eventtarget::{Capturing, Bubbling, EventTarget};
 use dom::event::{Event, PhaseAtTarget, PhaseNone, PhaseBubbling, PhaseCapturing};
 use dom::node::{Node, NodeHelpers};
@@ -15,13 +15,13 @@ use dom::virtualmethods::vtable_for;
 pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
                               pseudo_target: Option<JSRef<'b, EventTarget>>,
                               event: JSRef<Event>) -> bool {
-    assert!(!event.dispatching.get());
+    assert!(!event.dispatching());
 
-    event.target.assign(Some(match pseudo_target {
+    event.set_target(match pseudo_target {
         Some(pseudo_target) => pseudo_target,
         None => target.clone(),
-    }));
-    event.dispatching.set(true);
+    });
+    event.set_dispatching(true);
 
     let type_ = event.Type();
 
@@ -36,25 +36,25 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
         vec!()
     };
 
-    event.phase.set(PhaseCapturing);
+    event.set_phase(PhaseCapturing);
 
     //FIXME: The "callback this value" should be currentTarget
 
     /* capturing */
     for cur_target in chain.as_slice().iter().rev() {
         let stopped = match cur_target.get_listeners_for(type_.as_slice(), Capturing) {
             Some(listeners) => {
-                event.current_target.assign(Some(cur_target.deref().clone()));
+                event.set_current_target(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.stop_immediate.get() {
+                    if event.stop_immediate() {
                         break;
                     }
                 }
 
-                event.stop_propagation.get()
+                event.stop_propagation()
             }
             None => false
         };
@@ -65,41 +65,41 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
     }
 
     /* at target */
-    if !event.stop_propagation.get() {
-        event.phase.set(PhaseAtTarget);
-        event.current_target.assign(Some(target.clone()));
+    if !event.stop_propagation() {
+        event.set_phase(PhaseAtTarget);
+        event.set_current_target(target.clone());
 
         let opt_listeners = target.get_listeners(type_.as_slice());
         for listeners in opt_listeners.iter() {
             for listener in listeners.iter() {
                 // Explicitly drop any exception on the floor.
                 let _ = listener.HandleEvent_(target, event, ReportExceptions);
 
-                if event.stop_immediate.get() {
+                if event.stop_immediate() {
                     break;
                 }
             }
         }
     }
 
     /* bubbling */
-    if event.bubbles.get() && !event.stop_propagation.get() {
-        event.phase.set(PhaseBubbling);
+    if event.bubbles() && !event.stop_propagation() {
+        event.set_phase(PhaseBubbling);
 
         for cur_target in chain.iter() {
             let stopped = match cur_target.get_listeners_for(type_.as_slice(), Bubbling) {
                 Some(listeners) => {
-                    event.current_target.assign(Some(cur_target.deref().clone()));
+                    event.set_current_target(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.stop_immediate.get() {
+                        if event.stop_immediate() {
                             break;
                         }
                     }
 
-                    event.stop_propagation.get()
+                    event.stop_propagation()
                 }
                 None => false
             };
@@ -131,9 +131,9 @@ pub fn dispatch_event<'a, 'b>(target: JSRef<'a, EventTarget>,
         let _ = chain.pop();
     }
 
-    event.dispatching.set(false);
-    event.phase.set(PhaseNone);
-    event.current_target.clear();
+    event.set_dispatching(false);
+    event.set_phase(PhaseNone);
+    event.clear_current_target();
 
     !event.DefaultPrevented()
 }

components/script/dom/eventtarget.rs

@@ -128,7 +128,7 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
     fn dispatch_event_with_target(self,
                                   target: Option<JSRef<EventTarget>>,
                                   event: JSRef<Event>) -> Fallible<bool> {
-        if event.dispatching.get() || !event.initialized.get() {
+        if event.dispatching() || !event.initialized() {
             return Err(InvalidState);
         }
         Ok(dispatch_event(self, target, event))

components/script/dom/messageevent.rs

@@ -30,7 +30,7 @@ pub struct MessageEvent {
 
 impl MessageEventDerived for Event {
     fn is_messageevent(&self) -> bool {
-        self.type_id == MessageEventTypeId
+        *self.type_id() == MessageEventTypeId
     }
 }
 

components/script/dom/mouseevent.rs

@@ -38,7 +38,7 @@ pub struct MouseEvent {
 
 impl MouseEventDerived for Event {
     fn is_mouseevent(&self) -> bool {
-        self.type_id == MouseEventTypeId
+        *self.type_id() == MouseEventTypeId
     }
 }
 

components/script/dom/progressevent.rs

@@ -25,7 +25,7 @@ pub struct ProgressEvent {
 
 impl ProgressEventDerived for Event {
     fn is_progressevent(&self) -> bool {
-        self.type_id == ProgressEventTypeId
+        *self.type_id() == ProgressEventTypeId
     }
 }
 

components/script/dom/uievent.rs

@@ -30,7 +30,7 @@ pub struct UIEvent {
 
 impl UIEventDerived for Event {
     fn is_uievent(&self) -> bool {
-        self.type_id == UIEventTypeId
+        *self.type_id() == UIEventTypeId
     }
 }