Compile JS strings when setting inline event handlers via element attributes.

src/components/script/dom/eventtarget.rs

@@ -9,11 +9,12 @@ use dom::bindings::js::JSRef;
 use dom::bindings::utils::{Reflectable, Reflector};
 use dom::event::Event;
 use dom::eventdispatcher::dispatch_event;
-use dom::node::NodeTypeId;
+use dom::node::{Node, NodeTypeId, window_from_node};
 use dom::xmlhttprequest::XMLHttpRequestId;
 use dom::virtualmethods::VirtualMethods;
-use js::jsapi::JSObject;
+use js::jsapi::{JSObject, JS_CompileUCFunction, JS_GetFunctionObject, JS_CloneFunctionObject};
 use servo_util::str::DOMString;
+use libc::{c_char, size_t};
 use std::ptr;
 
 use collections::hashmap::HashMap;
@@ -90,6 +91,10 @@ pub trait EventTargetHelpers {
                                  ty: DOMString,
                                  listener: Option<EventListener>);
     fn get_inline_event_listener(&self, ty: DOMString) -> Option<EventListener>;
+    fn set_event_handler_uncompiled(&mut self,
+                                    content: &JSRef<Node>,
+                                    ty: &str,
+                                    source: DOMString);
     fn set_event_handler_common(&mut self, ty: &str, listener: *mut JSObject);
     fn get_event_handler_common(&self, ty: &str) -> *mut JSObject;
 }
@@ -145,6 +150,39 @@ impl<'a> EventTargetHelpers for JSRef<'a, EventTarget> {
         }).map(|entry| entry.listener.get_listener()))
     }
 
+    fn set_event_handler_uncompiled(&mut self,
+                                    content: &JSRef<Node>,
+                                    ty: &str,
+                                    source: DOMString) {
+        let win = window_from_node(content).root();
+        let cx = win.deref().get_cx();
+        let url = win.deref().get_url();
+        let url = url.to_str().to_c_str();
+        let name = ty.to_c_str();
+        let lineno = 0; //XXXjdm need to get a real number here
+
+        let nargs = 1; //XXXjdm not true for onerror
+        static arg_name: [c_char, ..6] =
+            ['e' as c_char, 'v' as c_char, 'e' as c_char, 'n' as c_char, 't' as c_char, 0];
+        static arg_names: [*c_char, ..1] = [&arg_name as *c_char];
+
+        let source = source.to_utf16();
+        let handler =
+            name.with_ref(|name| {
+            url.with_ref(|url| { unsafe {
+                let fun = JS_CompileUCFunction(cx, ptr::mut_null(), name,
+                                               nargs, &arg_names as **i8 as *mut *i8, source.as_ptr(),
+                                               source.len() as size_t,
+                                               url, lineno);
+                assert!(fun.is_not_null());
+                JS_GetFunctionObject(fun)
+            }})});
+        let scope = win.deref().reflector().get_jsobject();
+        let funobj = unsafe { JS_CloneFunctionObject(cx, handler, scope) };
+        assert!(funobj.is_not_null());
+        self.set_event_handler_common(ty, funobj)
+    }
+
     fn set_event_handler_common(&mut self, ty: &str, listener: *mut JSObject) {
         let listener = EventListener::new(listener);
         self.set_inline_event_listener(ty.to_owned(), Some(listener));

src/components/script/dom/htmlbodyelement.rs

@@ -3,14 +3,16 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use dom::bindings::codegen::BindingDeclarations::HTMLBodyElementBinding;
-use dom::bindings::codegen::InheritTypes::HTMLBodyElementDerived;
+use dom::bindings::codegen::InheritTypes::{HTMLBodyElementDerived, HTMLElementCast};
+use dom::bindings::codegen::InheritTypes::{EventTargetCast, NodeCast};
 use dom::bindings::error::ErrorResult;
 use dom::bindings::js::{JSRef, Temporary};
 use dom::document::Document;
 use dom::element::HTMLBodyElementTypeId;
-use dom::eventtarget::{EventTarget, NodeTargetTypeId};
+use dom::eventtarget::{EventTarget, NodeTargetTypeId, EventTargetHelpers};
 use dom::htmlelement::HTMLElement;
 use dom::node::{Node, ElementNodeTypeId, window_from_node};
+use dom::virtualmethods::VirtualMethods;
 use dom::window::WindowMethods;
 use js::jsapi::{JSContext, JSObject};
 use servo_util::str::DOMString;
@@ -115,3 +117,27 @@ impl<'a> HTMLBodyElementMethods for JSRef<'a, HTMLBodyElement> {
         win.SetOnunload(cx, listener)
     }
 }
+
+impl<'a> VirtualMethods for JSRef<'a, HTMLBodyElement> {
+    fn super_type<'a>(&'a mut self) -> Option<&'a mut VirtualMethods:> {
+        let element: &mut JSRef<HTMLElement> = HTMLElementCast::from_mut_ref(self);
+        Some(element as &mut VirtualMethods:)
+    }
+
+    fn after_set_attr(&mut self, name: DOMString, value: DOMString) {
+        match self.super_type() {
+            Some(ref mut s) => s.after_set_attr(name.clone(), value.clone()),
+            _ => (),
+        }
+
+        if name.starts_with("on") {
+            //XXXjdm This should only forward a subset of event handler names
+            let mut window = window_from_node(self).root();
+            let mut evtarget: &mut JSRef<EventTarget> = EventTargetCast::from_mut_ref(&mut *window);
+            let content: &mut JSRef<Node> = NodeCast::from_mut_ref(self);
+            evtarget.set_event_handler_uncompiled(content,
+                                                  name.slice_from(2).to_owned(),
+                                                  value);
+        }
+    }
+}

src/components/script/dom/virtualmethods.rs

@@ -4,6 +4,7 @@
 
 use dom::bindings::codegen::InheritTypes::ElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLAnchorElementCast;
+use dom::bindings::codegen::InheritTypes::HTMLBodyElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLIFrameElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLImageElementCast;
@@ -11,10 +12,11 @@ use dom::bindings::codegen::InheritTypes::HTMLObjectElementCast;
 use dom::bindings::codegen::InheritTypes::HTMLStyleElementCast;
 use dom::bindings::js::JSRef;
 use dom::element::Element;
-use dom::element::{ElementTypeId, HTMLAnchorElementTypeId, HTMLImageElementTypeId};
+use dom::element::{ElementTypeId, HTMLAnchorElementTypeId, HTMLBodyElementTypeId, HTMLImageElementTypeId};
 use dom::element::{HTMLIFrameElementTypeId, HTMLObjectElementTypeId, HTMLStyleElementTypeId};
 use dom::event::Event;
 use dom::htmlanchorelement::HTMLAnchorElement;
+use dom::htmlbodyelement::HTMLBodyElement;
 use dom::htmlelement::HTMLElement;
 use dom::htmliframeelement::HTMLIFrameElement;
 use dom::htmlimageelement::HTMLImageElement;
@@ -93,6 +95,10 @@ pub fn vtable_for<'a>(node: &'a mut JSRef<Node>) -> &'a mut VirtualMethods: {
             let element: &mut JSRef<HTMLAnchorElement> = HTMLAnchorElementCast::to_mut_ref(node).unwrap();
             element as &mut VirtualMethods:
         }
+        ElementNodeTypeId(HTMLBodyElementTypeId) => {
+            let element: &mut JSRef<HTMLBodyElement> = HTMLBodyElementCast::to_mut_ref(node).unwrap();
+            element as &mut VirtualMethods:
+        }
         ElementNodeTypeId(HTMLImageElementTypeId) => {
             let element: &mut JSRef<HTMLImageElement> = HTMLImageElementCast::to_mut_ref(node).unwrap();
             element as &mut VirtualMethods:

src/test/content/test_inline_event_handler.html

@@ -2,16 +2,8 @@
 <head>
 <script src="harness.js"></script>
 </head>
-<body>
+<body onload="is_a(event, Event); finish()">
 <script>
-  document.getElementsByTagName('body')[0].onload = function(ev) {
-    is_a(ev, Event);
-    ev.preventDefault();
-    is(ev.defaultPrevented, false);
-    is(ev.target, document);
-    is(ev.currentTarget, window);
-    finish();
-  }
 </script>
 </body>
 </html>