Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-24 17:14:33 +01:00
Code Issues Projects Releases Packages Wiki Activity

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

Browse source
This commit is contained in:
Josh Matthews 2014-04-22 01:17:12 -04:00 • committed by Ms2ger
parent 33955f0ab2
commit 04931adf70
4 changed files with 76 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

42
src/components/script/dom/eventtarget.rs
View file

@ -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));

30
src/components/script/dom/htmlbodyelement.rs
View file

@ -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);
}
}
}

8
src/components/script/dom/virtualmethods.rs
View file

@ -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: