Implement Event::new_initialized and initialize the event in Event::new.

src/components/script/dom/document.rs

@@ -546,7 +546,7 @@ impl<'a> DocumentMethods for JSRef<'a, Document> {
             "uievents" | "uievent" => Ok(EventCast::from_temporary(UIEvent::new_uninitialized(&*window))),
             "mouseevents" | "mouseevent" => Ok(EventCast::from_temporary(MouseEvent::new_uninitialized(&*window))),
             "customevent" => Ok(EventCast::from_temporary(CustomEvent::new_uninitialized(&*window))),
-            "htmlevents" | "events" | "event" => Ok(Event::new(&*window)),
+            "htmlevents" | "events" | "event" => Ok(Event::new_uninitialized(&*window)),
             _ => Err(NotSupported)
         }
     }

src/components/script/dom/event.rs

@@ -83,18 +83,25 @@ impl Event {
         }
     }
 
-    pub fn new(window: &JSRef<Window>) -> Temporary<Event> {
+    pub fn new_uninitialized(window: &JSRef<Window>) -> Temporary<Event> {
         reflect_dom_object(box Event::new_inherited(HTMLEventTypeId),
                            window,
                            EventBinding::Wrap)
     }
 
+    pub fn new(window: &JSRef<Window>,
+               type_: DOMString,
+               can_bubble: bool,
+               cancelable: bool) -> Temporary<Event> {
+        let mut event = Event::new_uninitialized(window).root();
+        event.InitEvent(type_, can_bubble, cancelable);
+        Temporary::from_rooted(&*event)
+    }
+
     pub fn Constructor(global: &JSRef<Window>,
                        type_: DOMString,
                        init: &EventBinding::EventInit) -> Fallible<Temporary<Event>> {
-        let mut ev = Event::new(global).root();
+        Ok(Event::new(global, type_, init.bubbles, init.cancelable))
-        ev.InitEvent(type_, init.bubbles, init.cancelable);
-        Ok(Temporary::from_rooted(&*ev))
     }
 }
 

src/components/script/dom/xmlhttprequest.rs

@@ -10,7 +10,7 @@ use dom::bindings::codegen::BindingDeclarations::XMLHttpRequestBinding::XMLHttpR
 use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast, XMLHttpRequestDerived};
 use dom::bindings::error::{ErrorResult, InvalidState, Network, Syntax, Security};
 use dom::document::Document;
-use dom::event::{Event, EventMethods};
+use dom::event::Event;
 use dom::eventtarget::{EventTarget, EventTargetHelpers, XMLHttpRequestTargetTypeId};
 use dom::bindings::conversions::ToJSValConvertible;
 use dom::bindings::error::Fallible;
@@ -564,8 +564,8 @@ impl<'a> PrivateXMLHttpRequestHelpers for JSRef<'a, XMLHttpRequest> {
     fn change_ready_state(&mut self, rs: XMLHttpRequestState) {
         self.ready_state = rs;
         let win = &*self.global.root();
-        let mut event = Event::new(win).root();
+        let mut event =
-        event.InitEvent("readystatechange".to_owned(), false, true);
+            Event::new(win, "readystatechange".to_owned(), false, true).root();
         let target: &JSRef<EventTarget> = EventTargetCast::from_ref(self);
         target.dispatch_event_with_target(None, &mut *event).ok();
     }

src/components/script/script_task.rs

@@ -15,7 +15,7 @@ use dom::bindings::utils::{wrap_for_same_compartment, pre_wrap};
 use dom::document::{Document, HTMLDocument, DocumentMethods, DocumentHelpers};
 use dom::element::{Element, AttributeHandlers};
 use dom::event::{Event_, ResizeEvent, ReflowEvent, ClickEvent, MouseDownEvent, MouseMoveEvent, MouseUpEvent};
-use dom::event::{Event, EventMethods};
+use dom::event::Event;
 use dom::uievent::UIEvent;
 use dom::eventtarget::{EventTarget, EventTargetHelpers};
 use dom::node;
@@ -1036,8 +1036,8 @@ 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 = Event::new(&*window).root();
+        let mut event =
-        event.InitEvent("load".to_owned(), false, false);
+            Event::new(&*window, "load".to_owned(), 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()),
@@ -1133,8 +1133,10 @@ impl ScriptTask {
                                 match *page.frame() {
                                     Some(ref frame) => {
                                         let window = frame.window.root();
-                                        let mut event = Event::new(&*window).root();
+                                        let mut event =
-                                        event.InitEvent("click".to_owned(), true, true);
+                                            Event::new(&*window,
+                                                       "click".to_owned(),
+                                                       true, true).root();
                                         let eventtarget: &JSRef<EventTarget> = EventTargetCast::from_ref(&node);
                                         let _ = eventtarget.dispatch_event_with_target(None, &mut *event);
                                     }