mshtml: Fixed nsAString handling in navigate_anchor.
[wine] / dlls / mshtml / mutation.c
1 /*
2  * Copyright 2008 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "config.h"
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "winreg.h"
29 #include "ole2.h"
30 #include "shlguid.h"
31
32 #include "mshtml_private.h"
33 #include "htmlevent.h"
34
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
38
39 #define IE_MAJOR_VERSION 7
40 #define IE_MINOR_VERSION 0
41
42 static const IID NS_ICONTENTUTILS_CID =
43     {0x762C4AE7,0xB923,0x422F,{0xB9,0x7E,0xB9,0xBF,0xC1,0xEF,0x7B,0xF0}};
44
45 static nsIContentUtils *content_utils;
46
47 static PRUnichar *handle_insert_comment(HTMLDocumentNode *doc, const PRUnichar *comment)
48 {
49     int majorv = 0, minorv = 0;
50     const PRUnichar *ptr, *end;
51     PRUnichar *buf;
52     DWORD len;
53
54     enum {
55         CMP_EQ,
56         CMP_LT,
57         CMP_LTE,
58         CMP_GT,
59         CMP_GTE
60     } cmpt = CMP_EQ;
61
62     static const PRUnichar endifW[] = {'<','!','[','e','n','d','i','f',']'};
63
64     if(comment[0] != '[' || comment[1] != 'i' || comment[2] != 'f')
65         return NULL;
66
67     ptr = comment+3;
68     while(isspaceW(*ptr))
69         ptr++;
70
71     if(ptr[0] == 'l' && ptr[1] == 't') {
72         ptr += 2;
73         if(*ptr == 'e') {
74             cmpt = CMP_LTE;
75             ptr++;
76         }else {
77             cmpt = CMP_LT;
78         }
79     }else if(ptr[0] == 'g' && ptr[1] == 't') {
80         ptr += 2;
81         if(*ptr == 'e') {
82             cmpt = CMP_GTE;
83             ptr++;
84         }else {
85             cmpt = CMP_GT;
86         }
87     }
88
89     if(!isspaceW(*ptr++))
90         return NULL;
91     while(isspaceW(*ptr))
92         ptr++;
93
94     if(ptr[0] != 'I' || ptr[1] != 'E')
95         return NULL;
96
97     ptr +=2;
98     if(!isspaceW(*ptr++))
99         return NULL;
100     while(isspaceW(*ptr))
101         ptr++;
102
103     if(!isdigitW(*ptr))
104         return NULL;
105     while(isdigitW(*ptr))
106         majorv = majorv*10 + (*ptr++ - '0');
107
108     if(*ptr == '.') {
109         ptr++;
110         if(!isdigitW(*ptr))
111             return NULL;
112         while(isdigitW(*ptr))
113             minorv = minorv*10 + (*ptr++ - '0');
114     }
115
116     while(isspaceW(*ptr))
117         ptr++;
118     if(ptr[0] != ']' || ptr[1] != '>')
119         return NULL;
120     ptr += 2;
121
122     len = strlenW(ptr);
123     if(len < sizeof(endifW)/sizeof(WCHAR))
124         return NULL;
125
126     end = ptr + len-sizeof(endifW)/sizeof(WCHAR);
127     if(memcmp(end, endifW, sizeof(endifW)))
128         return NULL;
129
130     switch(cmpt) {
131     case CMP_EQ:
132         if(majorv == IE_MAJOR_VERSION && minorv == IE_MINOR_VERSION)
133             break;
134         return NULL;
135     case CMP_LT:
136         if(majorv > IE_MAJOR_VERSION)
137             break;
138         if(majorv == IE_MAJOR_VERSION && minorv > IE_MINOR_VERSION)
139             break;
140         return NULL;
141     case CMP_LTE:
142         if(majorv > IE_MAJOR_VERSION)
143             break;
144         if(majorv == IE_MAJOR_VERSION && minorv >= IE_MINOR_VERSION)
145             break;
146         return NULL;
147     case CMP_GT:
148         if(majorv < IE_MAJOR_VERSION)
149             break;
150         if(majorv == IE_MAJOR_VERSION && minorv < IE_MINOR_VERSION)
151             break;
152         return NULL;
153     case CMP_GTE:
154         if(majorv < IE_MAJOR_VERSION)
155             break;
156         if(majorv == IE_MAJOR_VERSION && minorv <= IE_MINOR_VERSION)
157             break;
158         return NULL;
159     }
160
161     buf = heap_alloc((end-ptr+1)*sizeof(WCHAR));
162     if(!buf)
163         return NULL;
164
165     memcpy(buf, ptr, (end-ptr)*sizeof(WCHAR));
166     buf[end-ptr] = 0;
167
168     return buf;
169 }
170
171 static nsresult run_insert_comment(HTMLDocumentNode *doc, nsISupports *comment_iface, nsISupports *arg2)
172 {
173     const PRUnichar *comment;
174     nsIDOMComment *nscomment;
175     PRUnichar *replace_html;
176     nsAString comment_str;
177     nsresult nsres;
178
179     nsres = nsISupports_QueryInterface(comment_iface, &IID_nsIDOMComment, (void**)&nscomment);
180     if(NS_FAILED(nsres)) {
181         ERR("Could not get nsIDOMComment iface:%08x\n", nsres);
182         return nsres;
183     }
184
185     nsAString_Init(&comment_str, NULL);
186     nsres = nsIDOMComment_GetData(nscomment, &comment_str);
187     if(NS_FAILED(nsres))
188         return nsres;
189
190     nsAString_GetData(&comment_str, &comment);
191     replace_html = handle_insert_comment(doc, comment);
192     nsAString_Finish(&comment_str);
193
194     if(replace_html) {
195         HRESULT hres;
196
197         hres = replace_node_by_html(doc->nsdoc, (nsIDOMNode*)nscomment, replace_html);
198         heap_free(replace_html);
199         if(FAILED(hres))
200             nsres = NS_ERROR_FAILURE;
201     }
202
203
204     nsIDOMComment_Release(nscomment);
205     return nsres;
206 }
207
208 static nsresult run_bind_to_tree(HTMLDocumentNode *doc, nsISupports *nsiface, nsISupports *arg2)
209 {
210     nsIDOMNode *nsnode;
211     HTMLDOMNode *node;
212     nsresult nsres;
213     HRESULT hres;
214
215     TRACE("(%p)->(%p)\n", doc, nsiface);
216
217     nsres = nsISupports_QueryInterface(nsiface, &IID_nsIDOMNode, (void**)&nsnode);
218     if(NS_FAILED(nsres))
219         return nsres;
220
221     hres = get_node(doc, nsnode, TRUE, &node);
222     nsIDOMNode_Release(nsnode);
223     if(FAILED(hres)) {
224         ERR("Could not get node\n");
225         return nsres;
226     }
227
228     if(node->vtbl->bind_to_tree)
229         node->vtbl->bind_to_tree(node);
230
231     return nsres;
232 }
233
234 /* Calls undocumented 69 cmd of CGID_Explorer */
235 static void call_explorer_69(HTMLDocumentObj *doc)
236 {
237     IOleCommandTarget *olecmd;
238     VARIANT var;
239     HRESULT hres;
240
241     if(!doc->client)
242         return;
243
244     hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd);
245     if(FAILED(hres))
246         return;
247
248     VariantInit(&var);
249     hres = IOleCommandTarget_Exec(olecmd, &CGID_Explorer, 69, 0, NULL, &var);
250     IOleCommandTarget_Release(olecmd);
251     if(SUCCEEDED(hres) && V_VT(&var) != VT_NULL)
252         FIXME("handle result\n");
253 }
254
255 static void parse_complete(HTMLDocumentObj *doc)
256 {
257     TRACE("(%p)\n", doc);
258
259     if(doc->usermode == EDITMODE)
260         init_editor(&doc->basedoc);
261
262     call_explorer_69(doc);
263     if(doc->view_sink)
264         IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1);
265     call_property_onchanged(&doc->basedoc.cp_propnotif, 1005);
266     call_explorer_69(doc);
267
268     /* FIXME: IE7 calls EnableModelless(TRUE), EnableModelless(FALSE) and sets interactive state here */
269 }
270
271 static nsresult run_end_load(HTMLDocumentNode *This, nsISupports *arg1, nsISupports *arg2)
272 {
273     TRACE("(%p)\n", This);
274
275     if(!This->basedoc.doc_obj)
276         return NS_OK;
277
278     if(This == This->basedoc.doc_obj->basedoc.doc_node) {
279         /*
280          * This should be done in the worker thread that parses HTML,
281          * but we don't have such thread (Gecko parses HTML for us).
282          */
283         parse_complete(This->basedoc.doc_obj);
284     }
285
286     set_ready_state(This->basedoc.window, READYSTATE_INTERACTIVE);
287     return NS_OK;
288 }
289
290 static nsresult run_insert_script(HTMLDocumentNode *doc, nsISupports *script_iface, nsISupports *parser_iface)
291 {
292     nsIDOMHTMLScriptElement *nsscript;
293     nsIParser *nsparser = NULL;
294     nsresult nsres;
295
296     TRACE("(%p)->(%p)\n", doc, script_iface);
297
298     nsres = nsISupports_QueryInterface(script_iface, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript);
299     if(NS_FAILED(nsres)) {
300         ERR("Could not get nsIDOMHTMLScriptElement: %08x\n", nsres);
301         return nsres;
302     }
303
304     if(parser_iface) {
305         nsres = nsISupports_QueryInterface(parser_iface, &IID_nsIParser, (void**)&nsparser);
306         if(NS_FAILED(nsres)) {
307             ERR("Could not get nsIParser iface: %08x\n", nsres);
308             nsparser = NULL;
309         }
310     }
311
312     if(nsparser)
313         nsIParser_BeginEvaluatingParserInsertedScript(nsparser);
314
315     doc_insert_script(doc->basedoc.window, nsscript);
316
317     if(nsparser) {
318         nsIParser_EndEvaluatingParserInsertedScript(nsparser);
319         nsIParser_Release(nsparser);
320     }
321
322     nsIDOMHTMLScriptElement_Release(nsscript);
323     return NS_OK;
324 }
325
326 typedef struct nsRunnable nsRunnable;
327
328 typedef nsresult (*runnable_proc_t)(HTMLDocumentNode*,nsISupports*,nsISupports*);
329
330 struct nsRunnable {
331     nsIRunnable  nsIRunnable_iface;
332
333     LONG ref;
334
335     runnable_proc_t proc;
336
337     HTMLDocumentNode *doc;
338     nsISupports *arg1;
339     nsISupports *arg2;
340 };
341
342 static inline nsRunnable *impl_from_nsIRunnable(nsIRunnable *iface)
343 {
344     return CONTAINING_RECORD(iface, nsRunnable, nsIRunnable_iface);
345 }
346
347 static nsresult NSAPI nsRunnable_QueryInterface(nsIRunnable *iface,
348         nsIIDRef riid, void **result)
349 {
350     nsRunnable *This = impl_from_nsIRunnable(iface);
351
352     if(IsEqualGUID(riid, &IID_nsISupports)) {
353         TRACE("(%p)->(IID_nsISupports %p)\n", This, result);
354         *result = &This->nsIRunnable_iface;
355     }else if(IsEqualGUID(riid, &IID_nsIRunnable)) {
356         TRACE("(%p)->(IID_nsIRunnable %p)\n", This, result);
357         *result = &This->nsIRunnable_iface;
358     }else {
359         *result = NULL;
360         WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
361         return NS_NOINTERFACE;
362     }
363
364     nsISupports_AddRef((nsISupports*)*result);
365     return NS_OK;
366 }
367
368 static nsrefcnt NSAPI nsRunnable_AddRef(nsIRunnable *iface)
369 {
370     nsRunnable *This = impl_from_nsIRunnable(iface);
371     LONG ref = InterlockedIncrement(&This->ref);
372
373     TRACE("(%p) ref=%d\n", This, ref);
374
375     return ref;
376 }
377
378 static nsrefcnt NSAPI nsRunnable_Release(nsIRunnable *iface)
379 {
380     nsRunnable *This = impl_from_nsIRunnable(iface);
381     LONG ref = InterlockedDecrement(&This->ref);
382
383     TRACE("(%p) ref=%d\n", This, ref);
384
385     if(!ref) {
386         htmldoc_release(&This->doc->basedoc);
387         if(This->arg1)
388             nsISupports_Release(This->arg1);
389         if(This->arg2)
390             nsISupports_Release(This->arg2);
391         heap_free(This);
392     }
393
394     return ref;
395 }
396
397 static nsresult NSAPI nsRunnable_Run(nsIRunnable *iface)
398 {
399     nsRunnable *This = impl_from_nsIRunnable(iface);
400
401     return This->proc(This->doc, This->arg1, This->arg2);
402 }
403
404 static const nsIRunnableVtbl nsRunnableVtbl = {
405     nsRunnable_QueryInterface,
406     nsRunnable_AddRef,
407     nsRunnable_Release,
408     nsRunnable_Run
409 };
410
411 static void add_script_runner(HTMLDocumentNode *This, runnable_proc_t proc, nsISupports *arg1, nsISupports *arg2)
412 {
413     nsRunnable *runnable;
414
415     runnable = heap_alloc_zero(sizeof(*runnable));
416     if(!runnable)
417         return;
418
419     runnable->nsIRunnable_iface.lpVtbl = &nsRunnableVtbl;
420     runnable->ref = 1;
421
422     htmldoc_addref(&This->basedoc);
423     runnable->doc = This;
424     runnable->proc = proc;
425
426     if(arg1)
427         nsISupports_AddRef(arg1);
428     runnable->arg1 = arg1;
429
430     if(arg2)
431         nsISupports_AddRef(arg2);
432     runnable->arg2 = arg2;
433
434     nsIContentUtils_AddScriptRunner(content_utils, &runnable->nsIRunnable_iface);
435
436     nsIRunnable_Release(&runnable->nsIRunnable_iface);
437 }
438
439 static inline HTMLDocumentNode *impl_from_nsIDocumentObserver(nsIDocumentObserver *iface)
440 {
441     return CONTAINING_RECORD(iface, HTMLDocumentNode, nsIDocumentObserver_iface);
442 }
443
444 static nsresult NSAPI nsDocumentObserver_QueryInterface(nsIDocumentObserver *iface,
445         nsIIDRef riid, void **result)
446 {
447     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
448
449     if(IsEqualGUID(&IID_nsISupports, riid)) {
450         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
451         *result = &This->nsIDocumentObserver_iface;
452     }else if(IsEqualGUID(&IID_nsIMutationObserver, riid)) {
453         TRACE("(%p)->(IID_nsIMutationObserver %p)\n", This, result);
454         *result = &This->nsIDocumentObserver_iface;
455     }else if(IsEqualGUID(&IID_nsIDocumentObserver, riid)) {
456         TRACE("(%p)->(IID_nsIDocumentObserver %p)\n", This, result);
457         *result = &This->nsIDocumentObserver_iface;
458     }else {
459         *result = NULL;
460         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
461         return NS_NOINTERFACE;
462     }
463
464     htmldoc_addref(&This->basedoc);
465     return NS_OK;
466 }
467
468 static nsrefcnt NSAPI nsDocumentObserver_AddRef(nsIDocumentObserver *iface)
469 {
470     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
471     return htmldoc_addref(&This->basedoc);
472 }
473
474 static nsrefcnt NSAPI nsDocumentObserver_Release(nsIDocumentObserver *iface)
475 {
476     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
477     return htmldoc_release(&This->basedoc);
478 }
479
480 static void NSAPI nsDocumentObserver_CharacterDataWillChange(nsIDocumentObserver *iface,
481         nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo)
482 {
483 }
484
485 static void NSAPI nsDocumentObserver_CharacterDataChanged(nsIDocumentObserver *iface,
486         nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo)
487 {
488 }
489
490 static void NSAPI nsDocumentObserver_AttributeWillChange(nsIDocumentObserver *iface, nsIDocument *aDocument,
491         nsIContent *aContent, PRInt32 aNameSpaceID, nsIAtom *aAttribute, PRInt32 aModType)
492 {
493 }
494
495 static void NSAPI nsDocumentObserver_AttributeChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
496         nsIContent *aContent, PRInt32 aNameSpaceID, nsIAtom *aAttribute, PRInt32 aModType)
497 {
498 }
499
500 static void NSAPI nsDocumentObserver_ContentAppended(nsIDocumentObserver *iface, nsIDocument *aDocument,
501         nsIContent *aContainer, nsIContent *aFirstNewContent, PRInt32 aNewIndexInContainer)
502 {
503 }
504
505 static void NSAPI nsDocumentObserver_ContentInserted(nsIDocumentObserver *iface, nsIDocument *aDocument,
506         nsIContent *aContainer, nsIContent *aChild, PRInt32 aIndexInContainer)
507 {
508 }
509
510 static void NSAPI nsDocumentObserver_ContentRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument,
511         nsIContent *aContainer, nsIContent *aChild, PRInt32 aIndexInContainer,
512         nsIContent *aProviousSibling)
513 {
514 }
515
516 static void NSAPI nsDocumentObserver_NodeWillBeDestroyed(nsIDocumentObserver *iface, const nsINode *aNode)
517 {
518 }
519
520 static void NSAPI nsDocumentObserver_ParentChainChanged(nsIDocumentObserver *iface, nsIContent *aContent)
521 {
522 }
523
524 static void NSAPI nsDocumentObserver_BeginUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument,
525         nsUpdateType aUpdateType)
526 {
527 }
528
529 static void NSAPI nsDocumentObserver_EndUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument,
530         nsUpdateType aUpdateType)
531 {
532 }
533
534 static void NSAPI nsDocumentObserver_BeginLoad(nsIDocumentObserver *iface, nsIDocument *aDocument)
535 {
536 }
537
538 static void NSAPI nsDocumentObserver_EndLoad(nsIDocumentObserver *iface, nsIDocument *aDocument)
539 {
540     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
541
542     TRACE("(%p)\n", This);
543
544     if(This->skip_mutation_notif)
545         return;
546
547     This->content_ready = TRUE;
548     add_script_runner(This, run_end_load, NULL, NULL);
549 }
550
551 static void NSAPI nsDocumentObserver_ContentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
552         nsIContent *aContent1, nsIContent *aContent2, nsEventStates aStateMask)
553 {
554 }
555
556 static void NSAPI nsDocumentObserver_DocumentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
557         nsEventStates aStateMask)
558 {
559 }
560
561 static void NSAPI nsDocumentObserver_StyleSheetAdded(nsIDocumentObserver *iface, nsIDocument *aDocument,
562         nsIStyleSheet *aStyleSheet, PRBool aDocumentSheet)
563 {
564 }
565
566 static void NSAPI nsDocumentObserver_StyleSheetRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument,
567         nsIStyleSheet *aStyleSheet, PRBool aDocumentSheet)
568 {
569 }
570
571 static void NSAPI nsDocumentObserver_StyleSheetApplicableStateChanged(nsIDocumentObserver *iface,
572         nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, PRBool aApplicable)
573 {
574 }
575
576 static void NSAPI nsDocumentObserver_StyleRuleChanged(nsIDocumentObserver *iface, nsIDocument *aDocument,
577         nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule, nsIStyleSheet *aNewStyleRule)
578 {
579 }
580
581 static void NSAPI nsDocumentObserver_StyleRuleAdded(nsIDocumentObserver *iface, nsIDocument *aDocument,
582         nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule)
583 {
584 }
585
586 static void NSAPI nsDocumentObserver_StyleRuleRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument,
587         nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule)
588 {
589 }
590
591 static void NSAPI nsDocumentObserver_BindToDocument(nsIDocumentObserver *iface, nsIDocument *aDocument,
592         nsIContent *aContent)
593 {
594     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
595     nsIDOMHTMLIFrameElement *nsiframe;
596     nsIDOMHTMLFrameElement *nsframe;
597     nsIDOMComment *nscomment;
598     nsIDOMElement *nselem;
599     nsresult nsres;
600
601     TRACE("(%p)\n", This);
602
603     nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMElement, (void**)&nselem);
604     if(NS_SUCCEEDED(nsres)) {
605         check_event_attr(This, nselem);
606         nsIDOMElement_Release(nselem);
607     }
608
609     nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMComment, (void**)&nscomment);
610     if(NS_SUCCEEDED(nsres)) {
611         TRACE("comment node\n");
612
613         add_script_runner(This, run_insert_comment, (nsISupports*)nscomment, NULL);
614         nsIDOMComment_Release(nscomment);
615     }
616
617     nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMHTMLIFrameElement, (void**)&nsiframe);
618     if(NS_SUCCEEDED(nsres)) {
619         TRACE("iframe node\n");
620
621         add_script_runner(This, run_bind_to_tree, (nsISupports*)nsiframe, NULL);
622         nsIDOMHTMLIFrameElement_Release(nsiframe);
623     }
624
625     nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMHTMLFrameElement, (void**)&nsframe);
626     if(NS_SUCCEEDED(nsres)) {
627         TRACE("frame node\n");
628
629         add_script_runner(This, run_bind_to_tree, (nsISupports*)nsframe, NULL);
630         nsIDOMHTMLFrameElement_Release(nsframe);
631     }
632 }
633
634 static nsresult NSAPI nsDocumentObserver_DoneAddingChildren(nsIDocumentObserver *iface, nsIContent *aContent,
635         PRBool aHaveNotified, nsIParser *aParser)
636 {
637     HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface);
638     nsIDOMHTMLScriptElement *nsscript;
639     nsresult nsres;
640
641     TRACE("(%p)->(%p %x)\n", This, aContent, aHaveNotified);
642
643     nsres = nsISupports_QueryInterface(aContent, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript);
644     if(NS_SUCCEEDED(nsres)) {
645         TRACE("script node\n");
646
647         add_script_runner(This, run_insert_script, (nsISupports*)nsscript, (nsISupports*)aParser);
648         nsIDOMHTMLScriptElement_Release(nsscript);
649     }
650
651     return NS_OK;
652 }
653
654 static const nsIDocumentObserverVtbl nsDocumentObserverVtbl = {
655     nsDocumentObserver_QueryInterface,
656     nsDocumentObserver_AddRef,
657     nsDocumentObserver_Release,
658     nsDocumentObserver_CharacterDataWillChange,
659     nsDocumentObserver_CharacterDataChanged,
660     nsDocumentObserver_AttributeWillChange,
661     nsDocumentObserver_AttributeChanged,
662     nsDocumentObserver_ContentAppended,
663     nsDocumentObserver_ContentInserted,
664     nsDocumentObserver_ContentRemoved,
665     nsDocumentObserver_NodeWillBeDestroyed,
666     nsDocumentObserver_ParentChainChanged,
667     nsDocumentObserver_BeginUpdate,
668     nsDocumentObserver_EndUpdate,
669     nsDocumentObserver_BeginLoad,
670     nsDocumentObserver_EndLoad,
671     nsDocumentObserver_ContentStatesChanged,
672     nsDocumentObserver_DocumentStatesChanged,
673     nsDocumentObserver_StyleSheetAdded,
674     nsDocumentObserver_StyleSheetRemoved,
675     nsDocumentObserver_StyleSheetApplicableStateChanged,
676     nsDocumentObserver_StyleRuleChanged,
677     nsDocumentObserver_StyleRuleAdded,
678     nsDocumentObserver_StyleRuleRemoved,
679     nsDocumentObserver_BindToDocument,
680     nsDocumentObserver_DoneAddingChildren
681 };
682
683 void init_document_mutation(HTMLDocumentNode *doc)
684 {
685     nsIDocument *nsdoc;
686     nsresult nsres;
687
688     doc->nsIDocumentObserver_iface.lpVtbl = &nsDocumentObserverVtbl;
689
690     nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc);
691     if(NS_FAILED(nsres)) {
692         ERR("Could not get nsIDocument: %08x\n", nsres);
693         return;
694     }
695
696     nsIContentUtils_AddDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface);
697     nsIDocument_Release(nsdoc);
698 }
699
700 void release_document_mutation(HTMLDocumentNode *doc)
701 {
702     nsIDocument *nsdoc;
703     nsresult nsres;
704
705     nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc);
706     if(NS_FAILED(nsres)) {
707         ERR("Could not get nsIDocument: %08x\n", nsres);
708         return;
709     }
710
711     nsIContentUtils_RemoveDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface);
712     nsIDocument_Release(nsdoc);
713 }
714
715 void init_mutation(nsIComponentManager *component_manager)
716 {
717     nsIFactory *factory;
718     nsresult nsres;
719
720     if(!component_manager) {
721         if(content_utils) {
722             nsIContentUtils_Release(content_utils);
723             content_utils = NULL;
724         }
725         return;
726     }
727
728     nsres = nsIComponentManager_GetClassObject(component_manager, &NS_ICONTENTUTILS_CID,
729             &IID_nsIFactory, (void**)&factory);
730     if(NS_FAILED(nsres)) {
731         ERR("Could not create nsIContentUtils service: %08x\n", nsres);
732         return;
733     }
734
735     nsres = nsIFactory_CreateInstance(factory, NULL, &IID_nsIContentUtils, (void**)&content_utils);
736     nsIFactory_Release(factory);
737     if(NS_FAILED(nsres))
738         ERR("Could not create nsIContentUtils instance: %08x\n", nsres);
739 }