Cleanup CloseEvent.

components/script/dom/closeevent.rs

@@ -2,37 +2,35 @@
  * 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::cell::DOMRefCell;
 use dom::bindings::codegen::Bindings::EventBinding::EventMethods;
 use dom::bindings::codegen::Bindings::CloseEventBinding;
 use dom::bindings::codegen::Bindings::CloseEventBinding::CloseEventMethods;
 use dom::bindings::codegen::InheritTypes::EventCast;
 use dom::bindings::error::Fallible;
 use dom::bindings::global::GlobalRef;
-use dom::bindings::js::{JSRef,Temporary, Rootable};
+use dom::bindings::js::{JSRef, Temporary, Rootable};
 use dom::bindings::utils::reflect_dom_object;
 use dom::event::{Event, EventTypeId, EventBubbles, EventCancelable};
 use script_task::ScriptChan;
-use std::borrow::ToOwned;
-use std::cell::Cell;
-use util::str::DOMString;
 
+use util::str::DOMString;
 
 #[dom_struct]
-pub struct CloseEvent{
+pub struct CloseEvent {
     event: Event,
-    wasClean: Cell<bool>,
-    code: Cell<u16>,
-    reason: DOMRefCell<DOMString>
+    wasClean: bool,
+    code: u16,
+    reason: DOMString,
 }
 
-impl CloseEvent{
-    pub fn new_inherited(type_id: EventTypeId) -> CloseEvent{
-        CloseEvent{
+impl CloseEvent {
+    pub fn new_inherited(type_id: EventTypeId, wasClean: bool, code: u16,
+                         reason: DOMString) -> CloseEvent {
+        CloseEvent {
             event: Event::new_inherited(type_id),
-            wasClean: Cell::new(true),
-            code: Cell::new(0),
-            reason: DOMRefCell::new("".to_owned())
+            wasClean: wasClean,
+            code: code,
+            reason: reason,
         }
     }
 
@@ -43,47 +41,37 @@ impl CloseEvent{
                wasClean: bool,
                code: u16,
                reason: DOMString) -> Temporary<CloseEvent> {
-        let ev = reflect_dom_object(box CloseEvent::new_inherited(EventTypeId::CloseEvent),
-                                    global,
-                                    CloseEventBinding::Wrap);
-        let ev = ev.root();
+        let event = box CloseEvent::new_inherited(EventTypeId::CloseEvent,
+                                                  wasClean, code, reason);
+        let ev = reflect_dom_object(event, global, CloseEventBinding::Wrap).root();
         let event: JSRef<Event> = EventCast::from_ref(ev.r());
         event.InitEvent(type_,
                         bubbles == EventBubbles::Bubbles,
                         cancelable == EventCancelable::Cancelable);
-        let ev = ev.r();
-        ev.wasClean.set(wasClean);
-        ev.code.set(code);
-        *ev.reason.borrow_mut() = reason;
-        Temporary::from_rooted(ev)
+        Temporary::from_rooted(ev.r())
     }
 
     pub fn Constructor(global: GlobalRef,
                        type_: DOMString,
-                       init: &CloseEventBinding::CloseEventInit) -> Fallible<Temporary<CloseEvent>> {
-        let clean_status = init.wasClean.unwrap_or(true);
-        let cd = init.code.unwrap_or(0);
-        let rsn = match init.reason.as_ref() {
-            Some(reason) => reason.clone(),
-            None => "".to_owned(),
-        };
+                       init: &CloseEventBinding::CloseEventInit)
+                       -> Fallible<Temporary<CloseEvent>> {
         let bubbles = if init.parent.bubbles { EventBubbles::Bubbles } else { EventBubbles::DoesNotBubble };
         let cancelable = if init.parent.cancelable { EventCancelable::Cancelable } else { EventCancelable::NotCancelable };
-        Ok(CloseEvent::new(global, type_, bubbles, cancelable, clean_status, cd, rsn))
+        Ok(CloseEvent::new(global, type_, bubbles, cancelable, init.wasClean,
+                           init.code, init.reason.clone()))
     }
 }
 
-impl<'a> CloseEventMethods for JSRef<'a, CloseEvent>{
+impl<'a> CloseEventMethods for JSRef<'a, CloseEvent> {
     fn WasClean(self) -> bool {
-        self.wasClean.get()
+        self.wasClean
     }
 
     fn Code(self) -> u16 {
-        self.code.get()
+        self.code
     }
 
     fn Reason(self) -> DOMString {
-        let reason = self.reason.borrow();
-        reason.clone()
+        self.reason.clone()
     }
 }

components/script/dom/webidls/CloseEvent.webidl

@@ -11,7 +11,7 @@ interface CloseEvent : Event {
 };
 
 dictionary CloseEventInit : EventInit {
-  boolean wasClean;
-  unsigned short code;
-  DOMString reason;
+  boolean wasClean = false;
+  unsigned short code = 0;
+  DOMString reason = "";
 };