Merge branches/jmb/dom-alloc-purge back to trunk

svn path=/trunk/libdom/; revision=13316

1 files changed, 76 insertions, 634 deletions

diff --git a/src/events/event_target.c b/src/events/event_target.c
index 6bf5458..c4a2f90 100644
--- a/src/events/event_target.c
+++ b/src/events/event_target.c
@@ -6,8 +6,7 @@
  */
 
 #include <assert.h>
-
-#include <libwapcaplet/libwapcaplet.h>
+#include <stdlib.h>
 
 #include "events/event.h"
 #include "events/event_listener.h"
@@ -23,36 +22,74 @@
 /* The number of chains in the hash table used for hash event types */
 #define CHAINS 11
 
-/* Entry for a EventTarget, used to record the bubbling list */
-typedef struct dom_event_target_entry {
-	struct list_entry entry;	/**< The list entry */
-	dom_event_target *et;	/**< The node */
-} dom_event_target_entry;
+static uint32_t event_target_hash(void *key, void *pw)
+{
+	UNUSED(pw);
+
+	return dom_string_hash(key);
+}
+
+static void event_target_destroy_key(void *key, void *pw)
+{
+	UNUSED(pw);
+
+	dom_string_unref(key);
+}
+
+static void event_target_destroy_value(void *value, void *pw)
+{
+	struct listener_entry *le = NULL;
+	struct list_entry *i = (struct list_entry *) value;
+
+	UNUSED(pw);
+
+	while (i != i->next) {
+		le = (struct listener_entry *) i->next;
+		list_del(i->next);
+		dom_event_listener_unref(le->listener);
+		free(le);
+	}
+
+	le = (struct listener_entry *) i;
+	list_del(i);
+	dom_event_listener_unref(le->listener);
+	free(le);
+}
+
+static bool event_target_key_isequal(void *key1, void *key2, void *pw)
+{
+	UNUSED(pw);
 
-/* Hash key/value functions */
-static void *_key(void *key, void *key_pw, dom_alloc alloc, void *pw, 
-		bool clone);
-static void *_value(void *value, void *value_pw, dom_alloc alloc,
-		void *pw, bool clone);
+	return dom_string_isequal(key1, key2);
+}
 
+static const dom_hash_vtable event_target_vtable = {
+	event_target_hash,
+	NULL,
+	event_target_destroy_key,
+	NULL,
+	event_target_destroy_value,
+	event_target_key_isequal
+};
 
 /* Initialise this EventTarget */
-dom_exception _dom_event_target_internal_initialise(struct dom_document *doc,
+dom_exception _dom_event_target_internal_initialise(
 		dom_event_target_internal *eti)
 {
-	UNUSED(doc);
-	eti->listeners = NULL;
+	eti->listeners = _dom_hash_create(CHAINS, &event_target_vtable, NULL);
+	if (eti->listeners == NULL)
+		return DOM_NO_MEM_ERR;
+
 	eti->ns_listeners = NULL;
 
 	return DOM_NO_ERR;
 }
 
 /* Finalise this EventTarget */
-void _dom_event_target_internal_finalise(struct dom_document *doc, 
-		dom_event_target_internal *eti)
+void _dom_event_target_internal_finalise(dom_event_target_internal *eti)
 {
-	if (eti->listeners != NULL)
-		_dom_hash_destroy(eti->listeners, _key, NULL, _value, doc);
+	_dom_hash_destroy(eti->listeners);
+
 	/* TODO: Now, we did not support the EventListener with namespace,
 	 * when we support it, we should deal with the ns_listeners hash 
 	 * table, too.
@@ -71,42 +108,15 @@ void _dom_event_target_internal_finalise(struct dom_document *doc,
  * \param capture   Whether add this listener in the capturing phase
  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  */
-dom_exception _dom_event_target_add_event_listener(dom_event_target *et,
+dom_exception _dom_event_target_add_event_listener(
+		dom_event_target_internal *eti,
 		dom_string *type, struct dom_event_listener *listener, 
 		bool capture)
 {
 	struct listener_entry *le = NULL;
-	struct dom_document *doc = dom_node_get_owner(et);
-	assert(doc != NULL);
-
-	struct dom_event_target_internal *eti = &et->eti;
-	lwc_string *t = NULL;
-	dom_exception err;
-
-	/* If there is no hash table, we should create one firstly */
-	if (eti->listeners == NULL) {
-		err = _dom_document_create_hashtable(doc, CHAINS, 
-				_dom_hash_hash_lwcstring, &eti->listeners);
-		if (err != DOM_NO_ERR)
-			return err;
-	}
-
-	err = dom_string_get_intern(type, &t);
-	if (err != DOM_NO_ERR)
-		return err;
-
-	if (t == NULL) {
-		err = _dom_string_intern(type, &t);
-		if (err != DOM_NO_ERR)
-			return err;
-	} else {
-		lwc_string_ref(t);
-	}
-
-	assert(t != NULL);
+	dom_string *t = NULL;
 
-	le = (struct listener_entry *) _dom_document_alloc(doc, NULL, 
-			sizeof(struct listener_entry));
+	le = malloc(sizeof(struct listener_entry));
 	if (le == NULL)
 		return DOM_NO_MEM_ERR;
 	
@@ -116,6 +126,8 @@ dom_exception _dom_event_target_add_event_listener(dom_event_target *et,
 	dom_event_listener_ref(listener);
 	le->capture = capture;
 
+	t = dom_string_ref(type);
+
 	/* Find the type of this event */
 	struct list_entry *item = (struct list_entry *) _dom_hash_get(
 			eti->listeners, t);
@@ -140,42 +152,18 @@ dom_exception _dom_event_target_add_event_listener(dom_event_target *et,
  * \param capture   Whether the listener is registered at the capturing phase
  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  */
-dom_exception _dom_event_target_remove_event_listener(dom_event_target *et,
+dom_exception _dom_event_target_remove_event_listener(
+		dom_event_target_internal *eti,
 		dom_string *type, struct dom_event_listener *listener, 
 		bool capture)
 {
 	struct listener_entry *le = NULL;
-	struct dom_document *doc = dom_node_get_owner(et);
-	if (doc == NULL) {
-		/* TODO: In the progress of parsing, many Nodes in the DTD
-		 * has no document at all, do nothing for this kind of node */
-		return DOM_NO_ERR;
-	}
-
-	struct dom_event_target_internal *eti = &et->eti;
-	lwc_string *t = NULL;
-	dom_exception err;
-
-	err = dom_string_get_intern(type, &t);
-	if (err != DOM_NO_ERR)
-		return err;
-
-	if (t == NULL) {
-		err = _dom_string_intern(type, &t);
-		if (err != DOM_NO_ERR)
-			return err;
-	} else {
-		lwc_string_ref(t);
-	}
-
-	assert(t != NULL);
 
 	/* Find the type of this event */
 	struct list_entry *item = (struct list_entry *) _dom_hash_get(
-			eti->listeners, t);
+			eti->listeners, type);
 	if (item == NULL) {
 		/* There is no such event listener */
-		lwc_string_unref(t);
 		return DOM_NO_ERR;
 	} else {
 		struct list_entry *i = item;
@@ -186,8 +174,7 @@ dom_exception _dom_event_target_remove_event_listener(dom_event_target *et,
 				/* We found the listener */
 				list_del(i);
 				dom_event_listener_unref(le->listener);
-				_dom_document_alloc(doc, le,
-						sizeof(struct listener_entry));
+				free(le);
 				break;
 			}
 			i = i->next;
@@ -198,185 +185,6 @@ dom_exception _dom_event_target_remove_event_listener(dom_event_target *et,
 }
 
 /**
- * Dispatch an event into the implementation's event model
- *
- * \param et       The EventTarget object
- * \param evt      The event object
- * \param success  Indicates whether any of the listeners which handled the 
- *                 event called Event.preventDefault(). If 
- *                 Event.preventDefault() was called the returned value is 
- *                 false, else it is true.
- * \return DOM_NO_ERR                     on success
- *         DOM_DISPATCH_REQUEST_ERR       If the event is already in dispatch
- *         DOM_UNSPECIFIED_EVENT_TYPE_ERR If the type of the event is Null or
- *                                        empty string.
- *         DOM_NOT_SUPPORTED_ERR          If the event is not created by 
- *                                        Document.createEvent
- *         DOM_INVALID_CHARACTER_ERR      If the type of this event is not a
- *                                        valid NCName.
- */
-dom_exception _dom_event_target_dispatch_event(dom_event_target *et,
-		struct dom_event *evt, bool *success)
-{
-	assert(et != NULL);
-	assert(evt != NULL);
-
-	dom_exception err, ret = DOM_NO_ERR;
-
-	/* To test whether this event is in dispatch */
-	if (evt->in_dispatch == true) {
-		return DOM_DISPATCH_REQUEST_ERR;
-	} else {
-		evt->in_dispatch = true;
-	}
-
-	if (evt->type == NULL || lwc_string_length(evt->type) == 0) {
-		return DOM_UNSPECIFIED_EVENT_TYPE_ERR;
-	}
-
-	if (evt->doc == NULL)
-		return DOM_NOT_SUPPORTED_ERR;
-	
-	struct dom_document *doc = dom_node_get_owner(et);
-	if (doc == NULL) {
-		/* TODO: In the progress of parsing, many Nodes in the DTD has
-		 * no document at all, do nothing for this kind of node */
-		return DOM_NO_ERR;
-	}
-
-	dom_string *type = NULL;
-	err = _dom_document_create_string_from_lwcstring(doc, evt->type, &type);
-	if (err != DOM_NO_ERR)
-		return err;
-	
-	if (_dom_validate_ncname(type) == false) {
-		dom_string_unref(type);
-		return DOM_INVALID_CHARACTER_ERR;
-	}
-	dom_string_unref(type);
-
-	dom_event_target_entry list;
-	dom_event_target *target = et;
-
-	*success = true;
-
-	/* Compose the event target list */
-	list_init(&list.entry);
-	list.et = et;
-	dom_node_ref(et);
-	target = target->parent;
-
-	while (target != NULL) {
-		dom_event_target_entry *l = (dom_event_target_entry *) 
-				_dom_document_alloc(doc, NULL,
-				sizeof(dom_event_target_entry));
-		if (l == NULL) {
-			ret = DOM_NO_MEM_ERR;
-			goto cleanup;
-		}
-		list_append(&list.entry, &l->entry);
-		l->et = target;
-		dom_node_ref(target);
-		target = target->parent;
-	}
-
-	/* Fill the target of the event */
-	evt->target = et;
-	evt->phase = DOM_CAPTURING_PHASE;
-
-	/* The started callback of default action */
-	struct dom_document_event_internal *dei = &doc->dei;
-	void *pw = NULL; 
-	if (dei->actions != NULL) {
-		dom_default_action_callback cb = dei->actions(evt->type,
-				DOM_DEFAULT_ACTION_STARTED, &pw);
-		if (cb != NULL) {
-			cb(evt, pw);
-		}
-	}
-
-	/* The capture phase */
-	struct list_entry *e = list.entry.prev;
-	for (; e != &list.entry; e = e->prev) {
-		dom_event_target_entry *l = (dom_event_target_entry *) e;
-		err = _dom_event_target_dispatch(l->et, evt,
-				DOM_CAPTURING_PHASE, success);
-		if (err != DOM_NO_ERR) {
-			ret = err;
-			goto cleanup;
-		}
-		/* If the stopImmediatePropagation or stopPropagation is
-		 * called, we should break */
-		if (evt->stop_now == true || evt->stop == true)
-			goto cleanup;
-	}
-
-	/* Target phase */
-	evt->phase = DOM_AT_TARGET;
-	evt->current = et;
-	err = _dom_event_target_dispatch(et, evt, DOM_AT_TARGET, 
-			success);
-	if (evt->stop_now == true || evt->stop == true)
-		goto cleanup;
-
-	/* Bubbling phase */
-	evt->phase = DOM_BUBBLING_PHASE;
-
-	e = list.entry.next;
-	for (; e != &list.entry; e = e->next) {
-		dom_event_target_entry *l = (dom_event_target_entry *) e;
-		err = _dom_event_target_dispatch(l->et, evt,
-				DOM_BUBBLING_PHASE, success);
-		if (err != DOM_NO_ERR) {
-			ret = err;
-			goto cleanup;
-		}
-		/* If the stopImmediatePropagation or stopPropagation is
-		 * called, we should break */
-		if (evt->stop_now == true || evt->stop == true)
-			goto cleanup;
-	}
-
-	if (dei->actions == NULL)
-		goto cleanup;
-
-	/* The end callback of default action */
-	if (evt->prevent_default != true) {
-		dom_default_action_callback cb = dei->actions(evt->type,
-				DOM_DEFAULT_ACTION_END, &pw);
-		if (cb != NULL) {
-			cb(evt, pw);
-		}
-	}
-
-	/* The prevented callback of default action */
-	if (evt->prevent_default != true) {
-		dom_default_action_callback cb = dei->actions(evt->type,
-				DOM_DEFAULT_ACTION_PREVENTED, &pw);
-		if (cb != NULL) {
-			cb(evt, pw);
-		}
-	}
-
-cleanup:
-	if (evt->prevent_default == true) {
-		*success = false;
-	}
-
-	while (list.entry.next != &list.entry) {
-		dom_event_target_entry *e = (dom_event_target_entry *)
-				list.entry.next;
-		dom_node_unref(e->et);
-		list_del(list.entry.next);
-		_dom_document_alloc(doc, e, 0);
-	}
-
-	dom_node_unref(et);
-
-	return ret;
-}
-
-/**
  * Add an EventListener
  *
  * \param et         The EventTarget object
@@ -388,11 +196,12 @@ cleanup:
  *
  * We don't support this API now, so it always return DOM_NOT_SUPPORTED_ERR.
  */
-dom_exception _dom_event_target_add_event_listener_ns(dom_event_target *et,
+dom_exception _dom_event_target_add_event_listener_ns(
+		dom_event_target_internal *eti,
 		dom_string *namespace, dom_string *type, 
 		struct dom_event_listener *listener, bool capture)
 {
-	UNUSED(et);
+	UNUSED(eti);
 	UNUSED(namespace);
 	UNUSED(type);
 	UNUSED(listener);
@@ -413,11 +222,12 @@ dom_exception _dom_event_target_add_event_listener_ns(dom_event_target *et,
  *
  * We don't support this API now, so it always return DOM_NOT_SUPPORTED_ERR.
  */
-dom_exception _dom_event_target_remove_event_listener_ns(dom_event_target *et,
+dom_exception _dom_event_target_remove_event_listener_ns(
+		dom_event_target_internal *eti,
 		dom_string *namespace, dom_string *type, 
 		struct dom_event_listener *listener, bool capture)
 {
-	UNUSED(et);
+	UNUSED(eti);
 	UNUSED(namespace);
 	UNUSED(type);
 	UNUSED(listener);
@@ -428,61 +238,11 @@ dom_exception _dom_event_target_remove_event_listener_ns(dom_event_target *et,
 
 /*-------------------------------------------------------------------------*/
 
-/* The key process function of the hash table, see utils/hash_table.h for
- * detail */
-static void *_key(void *key, void *key_pw, dom_alloc alloc, void *pw, 
-		bool clone)
-{
-	UNUSED(key_pw);
-	UNUSED(alloc);
-	UNUSED(pw);
-	/* There should never be the requirement of clone the event listener
-	 * list */
-	assert(clone == false);
-	UNUSED(clone);
-
-	lwc_string_unref((lwc_string *) key);
-
-	return NULL;
-}
-
-/* The value process function of the hash table, see utils/hash_table.h for
- * detail */
-static void *_value(void *value, void *value_pw, dom_alloc alloc,
-		void *pw, bool clone)
-{
-	UNUSED(alloc);
-	UNUSED(pw);
-	/* There should never be the requirement of clone the event listener
-	 * list */
-	assert(clone == false);
-	UNUSED(clone);
-
-	struct listener_entry *le = NULL;
-	struct dom_document *doc = (struct dom_document *) value_pw;
-	struct list_entry *i = (struct list_entry *) value;
-
-	while(i != i->next) {
-		le = (struct listener_entry *) i->next;
-		list_del(i->next);
-		dom_event_listener_unref(le->listener);
-		_dom_document_alloc(doc, le, sizeof(struct listener_entry));
-	}
-
-	le = (struct listener_entry *) i;
-	list_del(i);
-	dom_event_listener_unref(le->listener);
-	_dom_document_alloc(doc, le, sizeof(struct listener_entry));
-
-	return NULL;
-}
-
-/*-------------------------------------------------------------------------*/
-
 /**
  * Dispatch an event on certain EventTarget
  *
  * \param et       The EventTarget object
+ * \param eti      Internal EventTarget object
  * \param evt      The event object
  * \param success  Indicates whether any of the listeners which handled the 
  *                 event called Event.preventDefault(). If 
@@ -490,12 +250,12 @@ static void *_value(void *value, void *value_pw, dom_alloc alloc,
  *                 false, else it is true.
  * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
  */
-dom_exception _dom_event_target_dispatch(dom_event_target *et, 
+dom_exception _dom_event_target_dispatch(dom_event_target *et,
+		dom_event_target_internal *eti, 
 		struct dom_event *evt, dom_event_flow_phase phase,
 		bool *success)
 {
-	struct dom_event_target_internal *eti = &et->eti;
-	lwc_string *t = evt->type; 
+	dom_string *t = evt->type; 
 
 	struct list_entry *item = (struct list_entry *) _dom_hash_get(
 			eti->listeners, t);
@@ -535,321 +295,3 @@ dom_exception _dom_event_target_dispatch(dom_event_target *et,
 	return DOM_NO_ERR;
 }
 
-/**
- * Dispatch a DOMNodeInserted/DOMNodeRemoved event
- *
- * \param doc      The document object
- * \param et       The EventTarget object
- * \param type     "DOMNodeInserted" or "DOMNodeRemoved"
- * \param related  The parent of the removed/inserted node
- * \param success  Whether this event's default action get called
- * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
- */
-dom_exception _dom_dispatch_node_change_event(struct dom_document *doc,
-		dom_event_target *et, dom_event_target *related, 
-		dom_mutation_type change, bool *success)
-{
-	struct dom_mutation_event *evt;
-	dom_exception err;
-
-	err = _dom_mutation_event_create(doc, &evt);
-	if (err != DOM_NO_ERR)
-		return err;
-	
-	lwc_string *type = NULL;
-	if (change == DOM_MUTATION_ADDITION) {
-		err = _dom_document_create_lwcstring(doc, 
-				(const uint8_t *) "DOMNodeInserted",
-				SLEN("DOMNodeInserted"), &type);
-		if (err != DOM_NO_ERR)
-			goto cleanup;
-	} else if (change == DOM_MUTATION_REMOVAL) {
-		err = _dom_document_create_lwcstring(doc, 
-				(const uint8_t *) "DOMNodeRemoval",
-				SLEN("DOMNodeRemoved"), &type);
-		if (err != DOM_NO_ERR)
-			goto cleanup;
-	} else {
-		assert("Should never be here" == NULL);
-	}
-
-	dom_string *t = NULL;
-	err = _dom_document_create_string_from_lwcstring(doc, type, &t);
-	_dom_document_unref_lwcstring(doc, type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	/* Initiliase the event with corresponding parameters */
-	err = dom_mutation_event_init(evt, t, true, false, related, NULL, NULL, 
-			NULL, change);
-	dom_string_unref(t);
-	if (err != DOM_NO_ERR) {
-		goto cleanup;
-	}
-
-	err = dom_event_target_dispatch_event(et, evt, success);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-	
-	/* Finalise the evt, and reuse it */
-	_dom_mutation_event_finalise(doc, evt);
-	/* Dispatch the DOMNodeInsertedIntoDocument/DOMNodeRemovedFromDocument 
-	 * event */
-	if (change == DOM_MUTATION_ADDITION) {
-		err = _dom_document_create_lwcstring(doc, 
-				(const uint8_t *) 
-					"DOMNodeInsertedIntoDocument", 
-				SLEN("DOMNodeInsertedIntoDocument"), &type);
-		if (err != DOM_NO_ERR)
-			goto cleanup;
-	} else if (change == DOM_MUTATION_REMOVAL) {
-		err = _dom_document_create_lwcstring(doc, 
-				(const uint8_t *) "DOMNodeRemovedFromDocument", 
-				SLEN("DOMNodeRemovedFromDocument"), &type);
-		if (err != DOM_NO_ERR)
-			goto cleanup;
-	} else {
-		assert("Should never be here" == NULL);
-	}
-
-	err = _dom_document_create_string_from_lwcstring(doc, type, &t);
-	_dom_document_unref_lwcstring(doc, type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	/* Dispatch the events for its children */
-	dom_event_target *target = et->first_child;
-	while (target != NULL) {
-		err = dom_mutation_event_init(evt, t, true, false, NULL,
-				NULL, NULL, NULL, change);
-		if (err != DOM_NO_ERR)
-			goto cleanup;
-
-		err = dom_event_target_dispatch_event(target, evt, success);
-		if (err != DOM_NO_ERR)
-			goto cleanup;
-
-		dom_event_target *p = dom_node_get_parent(target);
-		if (target->first_child != NULL) {
-			target = target->first_child;
-		} else if (target->next != NULL) {
-			target = target->next;
-		} else {
-			while (p != et && target == p->last_child) {
-				target = p;
-				p = dom_node_get_parent(p);
-			}
-
-			target = target->next;
-		}
-		/* Finalise the event for reuse in next iteration */
-		_dom_mutation_event_finalise(doc, evt);
-	}
-
-cleanup:
-	_dom_mutation_event_destroy(doc, evt);
-
-	return err;
-}
-
-/**
- * Dispatch a DOMAttrModified event
- *
- * \param doc        The Document object
- * \param et         The EventTarget
- * \param prev       The previous value before change
- * \param new        The new value after change
- * \param related    The related EventTarget
- * \param attr_name  The Attribute name
- * \param change     How this attribute change
- * \param success    Whether this event's default handler get called
- * \return DOM_NO_ERR on success, appropirate dom_exception on failure.
- */
-dom_exception _dom_dispatch_attr_modified_event(struct dom_document *doc,
-		dom_event_target *et, dom_string *prev, dom_string *new,
-		dom_event_target *related, dom_string *attr_name, 
-		dom_mutation_type change, bool *success)
-{
-	struct dom_mutation_event *evt;
-	dom_exception err;
-
-	err = _dom_mutation_event_create(doc, &evt);
-	if (err != DOM_NO_ERR)
-		return err;
-	
-	lwc_string *type = NULL;
-	err = _dom_document_create_lwcstring(doc, 
-			(const uint8_t *) "DOMAttrModified",
-			SLEN("DOMAttrModified"), &type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	dom_string *t = NULL;
-	err = _dom_document_create_string_from_lwcstring(doc, type, &t);
-	_dom_document_unref_lwcstring(doc, type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	/* Initiliase the event with corresponding parameters */
-	err = dom_mutation_event_init(evt, t, true, false, related, prev, new,
-			attr_name, change);
-	dom_string_unref(t);
-	if (err != DOM_NO_ERR) {
-		goto cleanup;
-	}
-
-	err = dom_event_target_dispatch_event(et, evt, success);
-
-cleanup:
-	_dom_mutation_event_destroy(doc, evt);
-
-	return err;
-}
-
-/**
- * Dispatch a DOMCharacterDataModified event
- *
- * \param et       The EventTarget object
- * \param prev     The preValue of the DOMCharacterData
- * \param new      The newValue of the DOMCharacterData
- * \param success  Whether this event's default handler get called
- * \return DOM_NO_ERR on success, appropirate dom_exception on failure.
- *
- * TODO:
- * The character_data object may be a part of a Attr node, if so, another 
- * DOMAttrModified event should be dispatched, too. But for now, we did not
- * support any XML feature, so just leave it as this.
- */
-dom_exception _dom_dispatch_characterdata_modified_event(
-		struct dom_document *doc, dom_event_target *et,
-		dom_string *prev, dom_string *new, bool *success)
-{
-	struct dom_mutation_event *evt;
-	dom_exception err;
-
-	err = _dom_mutation_event_create(doc, &evt);
-	if (err != DOM_NO_ERR)
-		return err;
-	
-	lwc_string *type = NULL;
-	err = _dom_document_create_lwcstring(doc, 
-			(const uint8_t *) "DOMCharacterDataModified",
-			SLEN("DOMCharacterDataModified"), &type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	dom_string *t = NULL;
-	err = _dom_document_create_string_from_lwcstring(doc, type, &t);
-	_dom_document_unref_lwcstring(doc, type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	err = dom_mutation_event_init(evt, t, true, false, et, prev, new, NULL,
-			DOM_MUTATION_MODIFICATION);
-	dom_string_unref(t);
-	if (err != DOM_NO_ERR) {
-		goto cleanup;
-	}
-
-	err = dom_event_target_dispatch_event(et, evt, success);
-
-cleanup:
-	_dom_mutation_event_destroy(doc, evt);
-
-	return err;
-}
-
-/**
- * Dispatch a DOMSubtreeModified event
- *
- * \param doc      The Document
- * \param et       The EventTarget object
- * \param success  Whether this event's default handler get called
- * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
- */
-dom_exception _dom_dispatch_subtree_modified_event(struct dom_document *doc,
-		dom_event_target *et, bool *success)
-{
-	struct dom_mutation_event *evt;
-	dom_exception err;
-
-	err = _dom_mutation_event_create(doc, &evt);
-	if (err != DOM_NO_ERR)
-		return err;
-	
-	lwc_string *type = NULL;
-	err = _dom_document_create_lwcstring(doc, 
-			(const uint8_t *) "DOMSubtreeModified",
-			SLEN("DOMSubtreeModified"), &type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	dom_string *t = NULL;
-	err = _dom_document_create_string_from_lwcstring(doc, type, &t);
-	_dom_document_unref_lwcstring(doc, type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	err = dom_mutation_event_init(evt, t, true, false, et, NULL, NULL, NULL,
-			DOM_MUTATION_MODIFICATION);
-	dom_string_unref(t);
-	if (err != DOM_NO_ERR) {
-		goto cleanup;
-	}
-
-	err = dom_event_target_dispatch_event(et, evt, success);
-
-cleanup:
-	_dom_mutation_event_destroy(doc, evt);
-
-	return err;
-}
-
-/**
- * Dispatch a generic event
- *
- * \param doc         The Document
- * \param et          The EventTarget object
- * \param name        The name of the event
- * \param len         The length of the name string
- * \param bubble      Whether this event bubbles
- * \param cancelable  Whether this event can be cancelable
- * \param success     Whether this event's default handler get called
- * \return DOM_NO_ERR on success, appropriate dom_exception on failure.
- */
-dom_exception _dom_dispatch_generic_event(struct dom_document *doc,
-		dom_event_target *et, const uint8_t *name, size_t len,
-		bool bubble, bool cancelable, bool *success)
-{
-	struct dom_event *evt;
-	dom_exception err;
-
-	err = _dom_event_create(doc, &evt);
-	if (err != DOM_NO_ERR)
-		return err;
-	
-	lwc_string *type = NULL;
-	err = _dom_document_create_lwcstring(doc, name, len, &type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	dom_string *t = NULL;
-	err = _dom_document_create_string_from_lwcstring(doc, type, &t);
-	_dom_document_unref_lwcstring(doc, type);
-	if (err != DOM_NO_ERR)
-		goto cleanup;
-
-	err = dom_event_init(evt, t, bubble, cancelable);
-	dom_string_unref(t);
-	if (err != DOM_NO_ERR) {
-		goto cleanup;
-	}
-
-	err = dom_event_target_dispatch_event(et, evt, success);
-
-cleanup:
-	_dom_event_destroy(doc, evt);
-
-	return err;
-}
-