/* * Copyright 2008 Jacek Caban for CodeWeavers * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #include "config.h" #include <stdarg.h> #include <assert.h> #define COBJMACROS #include "windef.h" #include "winbase.h" #include "winuser.h" #include "winreg.h" #include "ole2.h" #include "shlguid.h" #include "mshtml_private.h" #include "htmlscript.h" #include "htmlevent.h" #include "binding.h" #include "wine/debug.h" WINE_DEFAULT_DEBUG_CHANNEL(mshtml); #define IE_MAJOR_VERSION 7 #define IE_MINOR_VERSION 0 static const IID NS_ICONTENTUTILS_CID = {0x762C4AE7,0xB923,0x422F,{0xB9,0x7E,0xB9,0xBF,0xC1,0xEF,0x7B,0xF0}}; static nsIContentUtils *content_utils; static PRUnichar *handle_insert_comment(HTMLDocumentNode *doc, const PRUnichar *comment) { int majorv = 0, minorv = 0; const PRUnichar *ptr, *end; PRUnichar *buf; DWORD len; enum { CMP_EQ, CMP_LT, CMP_LTE, CMP_GT, CMP_GTE } cmpt = CMP_EQ; static const PRUnichar endifW[] = {'<','!','[','e','n','d','i','f',']'}; if(comment[0] != '[' || comment[1] != 'i' || comment[2] != 'f') return NULL; ptr = comment+3; while(isspaceW(*ptr)) ptr++; if(ptr[0] == 'l' && ptr[1] == 't') { ptr += 2; if(*ptr == 'e') { cmpt = CMP_LTE; ptr++; }else { cmpt = CMP_LT; } }else if(ptr[0] == 'g' && ptr[1] == 't') { ptr += 2; if(*ptr == 'e') { cmpt = CMP_GTE; ptr++; }else { cmpt = CMP_GT; } } if(!isspaceW(*ptr++)) return NULL; while(isspaceW(*ptr)) ptr++; if(ptr[0] != 'I' || ptr[1] != 'E') return NULL; ptr +=2; if(!isspaceW(*ptr++)) return NULL; while(isspaceW(*ptr)) ptr++; if(!isdigitW(*ptr)) return NULL; while(isdigitW(*ptr)) majorv = majorv*10 + (*ptr++ - '0'); if(*ptr == '.') { ptr++; if(!isdigitW(*ptr)) return NULL; while(isdigitW(*ptr)) minorv = minorv*10 + (*ptr++ - '0'); } while(isspaceW(*ptr)) ptr++; if(ptr[0] != ']' || ptr[1] != '>') return NULL; ptr += 2; len = strlenW(ptr); if(len < sizeof(endifW)/sizeof(WCHAR)) return NULL; end = ptr + len-sizeof(endifW)/sizeof(WCHAR); if(memcmp(end, endifW, sizeof(endifW))) return NULL; switch(cmpt) { case CMP_EQ: if(majorv == IE_MAJOR_VERSION && minorv == IE_MINOR_VERSION) break; return NULL; case CMP_LT: if(majorv > IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv > IE_MINOR_VERSION) break; return NULL; case CMP_LTE: if(majorv > IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv >= IE_MINOR_VERSION) break; return NULL; case CMP_GT: if(majorv < IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv < IE_MINOR_VERSION) break; return NULL; case CMP_GTE: if(majorv < IE_MAJOR_VERSION) break; if(majorv == IE_MAJOR_VERSION && minorv <= IE_MINOR_VERSION) break; return NULL; } buf = heap_alloc((end-ptr+1)*sizeof(WCHAR)); if(!buf) return NULL; memcpy(buf, ptr, (end-ptr)*sizeof(WCHAR)); buf[end-ptr] = 0; return buf; } static nsresult run_insert_comment(HTMLDocumentNode *doc, nsISupports *comment_iface, nsISupports *arg2) { const PRUnichar *comment; nsIDOMComment *nscomment; PRUnichar *replace_html; nsAString comment_str; nsresult nsres; nsres = nsISupports_QueryInterface(comment_iface, &IID_nsIDOMComment, (void**)&nscomment); if(NS_FAILED(nsres)) { ERR("Could not get nsIDOMComment iface:%08x\n", nsres); return nsres; } nsAString_Init(&comment_str, NULL); nsres = nsIDOMComment_GetData(nscomment, &comment_str); if(NS_FAILED(nsres)) return nsres; nsAString_GetData(&comment_str, &comment); replace_html = handle_insert_comment(doc, comment); nsAString_Finish(&comment_str); if(replace_html) { HRESULT hres; hres = replace_node_by_html(doc->nsdoc, (nsIDOMNode*)nscomment, replace_html); heap_free(replace_html); if(FAILED(hres)) nsres = NS_ERROR_FAILURE; } nsIDOMComment_Release(nscomment); return nsres; } static nsresult run_bind_to_tree(HTMLDocumentNode *doc, nsISupports *nsiface, nsISupports *arg2) { nsIDOMNode *nsnode; HTMLDOMNode *node; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p)\n", doc, nsiface); nsres = nsISupports_QueryInterface(nsiface, &IID_nsIDOMNode, (void**)&nsnode); if(NS_FAILED(nsres)) return nsres; hres = get_node(doc, nsnode, TRUE, &node); nsIDOMNode_Release(nsnode); if(FAILED(hres)) { ERR("Could not get node\n"); return nsres; } if(node->vtbl->bind_to_tree) node->vtbl->bind_to_tree(node); node_release(node); return nsres; } /* Calls undocumented 69 cmd of CGID_Explorer */ static void call_explorer_69(HTMLDocumentObj *doc) { IOleCommandTarget *olecmd; VARIANT var; HRESULT hres; if(!doc->client) return; hres = IOleClientSite_QueryInterface(doc->client, &IID_IOleCommandTarget, (void**)&olecmd); if(FAILED(hres)) return; VariantInit(&var); hres = IOleCommandTarget_Exec(olecmd, &CGID_Explorer, 69, 0, NULL, &var); IOleCommandTarget_Release(olecmd); if(SUCCEEDED(hres) && V_VT(&var) != VT_NULL) FIXME("handle result\n"); } static void parse_complete(HTMLDocumentObj *doc) { TRACE("(%p)\n", doc); if(doc->usermode == EDITMODE) init_editor(&doc->basedoc); call_explorer_69(doc); if(doc->view_sink) IAdviseSink_OnViewChange(doc->view_sink, DVASPECT_CONTENT, -1); call_property_onchanged(&doc->basedoc.cp_container, 1005); call_explorer_69(doc); if(doc->webbrowser && doc->usermode != EDITMODE && !(doc->basedoc.window->load_flags & BINDING_REFRESH)) IDocObjectService_FireNavigateComplete2(doc->doc_object_service, &doc->basedoc.window->base.IHTMLWindow2_iface, 0); /* FIXME: IE7 calls EnableModelless(TRUE), EnableModelless(FALSE) and sets interactive state here */ } static nsresult run_end_load(HTMLDocumentNode *This, nsISupports *arg1, nsISupports *arg2) { TRACE("(%p)\n", This); if(!This->basedoc.doc_obj) return NS_OK; if(This == This->basedoc.doc_obj->basedoc.doc_node) { /* * This should be done in the worker thread that parses HTML, * but we don't have such thread (Gecko parses HTML for us). */ parse_complete(This->basedoc.doc_obj); } bind_event_scripts(This); set_ready_state(This->basedoc.window, READYSTATE_INTERACTIVE); return NS_OK; } static nsresult run_insert_script(HTMLDocumentNode *doc, nsISupports *script_iface, nsISupports *parser_iface) { nsIDOMHTMLScriptElement *nsscript; HTMLScriptElement *script_elem; nsIParser *nsparser = NULL; script_queue_entry_t *iter; HTMLInnerWindow *window; nsresult nsres; HRESULT hres; TRACE("(%p)->(%p)\n", doc, script_iface); window = doc->window; if(!window) return NS_OK; nsres = nsISupports_QueryInterface(script_iface, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript); if(NS_FAILED(nsres)) { ERR("Could not get nsIDOMHTMLScriptElement: %08x\n", nsres); return nsres; } if(parser_iface) { nsres = nsISupports_QueryInterface(parser_iface, &IID_nsIParser, (void**)&nsparser); if(NS_FAILED(nsres)) { ERR("Could not get nsIParser iface: %08x\n", nsres); nsparser = NULL; } } hres = script_elem_from_nsscript(doc, nsscript, &script_elem); nsIDOMHTMLScriptElement_Release(nsscript); if(FAILED(hres)) return NS_ERROR_FAILURE; if(nsparser) { nsIParser_BeginEvaluatingParserInsertedScript(nsparser); window->parser_callback_cnt++; } IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface); doc_insert_script(window, script_elem); while(!list_empty(&window->script_queue)) { iter = LIST_ENTRY(list_head(&window->script_queue), script_queue_entry_t, entry); list_remove(&iter->entry); if(!iter->script->parsed) doc_insert_script(window, iter->script); IHTMLScriptElement_Release(&iter->script->IHTMLScriptElement_iface); heap_free(iter); } IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface); if(nsparser) { window->parser_callback_cnt--; nsIParser_EndEvaluatingParserInsertedScript(nsparser); nsIParser_Release(nsparser); } IHTMLScriptElement_Release(&script_elem->IHTMLScriptElement_iface); return NS_OK; } typedef struct nsRunnable nsRunnable; typedef nsresult (*runnable_proc_t)(HTMLDocumentNode*,nsISupports*,nsISupports*); struct nsRunnable { nsIRunnable nsIRunnable_iface; LONG ref; runnable_proc_t proc; HTMLDocumentNode *doc; nsISupports *arg1; nsISupports *arg2; }; static inline nsRunnable *impl_from_nsIRunnable(nsIRunnable *iface) { return CONTAINING_RECORD(iface, nsRunnable, nsIRunnable_iface); } static nsresult NSAPI nsRunnable_QueryInterface(nsIRunnable *iface, nsIIDRef riid, void **result) { nsRunnable *This = impl_from_nsIRunnable(iface); if(IsEqualGUID(riid, &IID_nsISupports)) { TRACE("(%p)->(IID_nsISupports %p)\n", This, result); *result = &This->nsIRunnable_iface; }else if(IsEqualGUID(riid, &IID_nsIRunnable)) { TRACE("(%p)->(IID_nsIRunnable %p)\n", This, result); *result = &This->nsIRunnable_iface; }else { *result = NULL; WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), result); return NS_NOINTERFACE; } nsISupports_AddRef((nsISupports*)*result); return NS_OK; } static nsrefcnt NSAPI nsRunnable_AddRef(nsIRunnable *iface) { nsRunnable *This = impl_from_nsIRunnable(iface); LONG ref = InterlockedIncrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); return ref; } static nsrefcnt NSAPI nsRunnable_Release(nsIRunnable *iface) { nsRunnable *This = impl_from_nsIRunnable(iface); LONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) ref=%d\n", This, ref); if(!ref) { htmldoc_release(&This->doc->basedoc); if(This->arg1) nsISupports_Release(This->arg1); if(This->arg2) nsISupports_Release(This->arg2); heap_free(This); } return ref; } static nsresult NSAPI nsRunnable_Run(nsIRunnable *iface) { nsRunnable *This = impl_from_nsIRunnable(iface); return This->proc(This->doc, This->arg1, This->arg2); } static const nsIRunnableVtbl nsRunnableVtbl = { nsRunnable_QueryInterface, nsRunnable_AddRef, nsRunnable_Release, nsRunnable_Run }; static void add_script_runner(HTMLDocumentNode *This, runnable_proc_t proc, nsISupports *arg1, nsISupports *arg2) { nsRunnable *runnable; runnable = heap_alloc_zero(sizeof(*runnable)); if(!runnable) return; runnable->nsIRunnable_iface.lpVtbl = &nsRunnableVtbl; runnable->ref = 1; htmldoc_addref(&This->basedoc); runnable->doc = This; runnable->proc = proc; if(arg1) nsISupports_AddRef(arg1); runnable->arg1 = arg1; if(arg2) nsISupports_AddRef(arg2); runnable->arg2 = arg2; nsIContentUtils_AddScriptRunner(content_utils, &runnable->nsIRunnable_iface); nsIRunnable_Release(&runnable->nsIRunnable_iface); } static inline HTMLDocumentNode *impl_from_nsIDocumentObserver(nsIDocumentObserver *iface) { return CONTAINING_RECORD(iface, HTMLDocumentNode, nsIDocumentObserver_iface); } static nsresult NSAPI nsDocumentObserver_QueryInterface(nsIDocumentObserver *iface, nsIIDRef riid, void **result) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); if(IsEqualGUID(&IID_nsISupports, riid)) { TRACE("(%p)->(IID_nsISupports, %p)\n", This, result); *result = &This->nsIDocumentObserver_iface; }else if(IsEqualGUID(&IID_nsIMutationObserver, riid)) { TRACE("(%p)->(IID_nsIMutationObserver %p)\n", This, result); *result = &This->nsIDocumentObserver_iface; }else if(IsEqualGUID(&IID_nsIDocumentObserver, riid)) { TRACE("(%p)->(IID_nsIDocumentObserver %p)\n", This, result); *result = &This->nsIDocumentObserver_iface; }else { *result = NULL; TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result); return NS_NOINTERFACE; } htmldoc_addref(&This->basedoc); return NS_OK; } static nsrefcnt NSAPI nsDocumentObserver_AddRef(nsIDocumentObserver *iface) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); return htmldoc_addref(&This->basedoc); } static nsrefcnt NSAPI nsDocumentObserver_Release(nsIDocumentObserver *iface) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); return htmldoc_release(&This->basedoc); } static void NSAPI nsDocumentObserver_CharacterDataWillChange(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo) { } static void NSAPI nsDocumentObserver_CharacterDataChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, void /*CharacterDataChangeInfo*/ *aInfo) { } static void NSAPI nsDocumentObserver_AttributeWillChange(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, LONG aNameSpaceID, nsIAtom *aAttribute, LONG aModType) { } static void NSAPI nsDocumentObserver_AttributeChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, LONG aNameSpaceID, nsIAtom *aAttribute, LONG aModType) { } static void NSAPI nsDocumentObserver_AttributeSetToCurrentValue(nsIDocumentObserver *iface, nsIDocument *aDocument, void *aElement, LONG aNameSpaceID, nsIAtom *aAttribute) { } static void NSAPI nsDocumentObserver_ContentAppended(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aFirstNewContent, LONG aNewIndexInContainer) { } static void NSAPI nsDocumentObserver_ContentInserted(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild, LONG aIndexInContainer) { } static void NSAPI nsDocumentObserver_ContentRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContainer, nsIContent *aChild, LONG aIndexInContainer, nsIContent *aProviousSibling) { } static void NSAPI nsDocumentObserver_NodeWillBeDestroyed(nsIDocumentObserver *iface, const nsINode *aNode) { } static void NSAPI nsDocumentObserver_ParentChainChanged(nsIDocumentObserver *iface, nsIContent *aContent) { } static void NSAPI nsDocumentObserver_BeginUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument, nsUpdateType aUpdateType) { } static void NSAPI nsDocumentObserver_EndUpdate(nsIDocumentObserver *iface, nsIDocument *aDocument, nsUpdateType aUpdateType) { } static void NSAPI nsDocumentObserver_BeginLoad(nsIDocumentObserver *iface, nsIDocument *aDocument) { } static void NSAPI nsDocumentObserver_EndLoad(nsIDocumentObserver *iface, nsIDocument *aDocument) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); TRACE("(%p)\n", This); if(This->skip_mutation_notif) return; This->content_ready = TRUE; add_script_runner(This, run_end_load, NULL, NULL); } static void NSAPI nsDocumentObserver_ContentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent, nsEventStates *aStateMask) { } static void NSAPI nsDocumentObserver_DocumentStatesChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsEventStates *aStateMask) { } static void NSAPI nsDocumentObserver_StyleSheetAdded(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, cpp_bool aDocumentSheet) { } static void NSAPI nsDocumentObserver_StyleSheetRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, cpp_bool aDocumentSheet) { } static void NSAPI nsDocumentObserver_StyleSheetApplicableStateChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, cpp_bool aApplicable) { } static void NSAPI nsDocumentObserver_StyleRuleChanged(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aOldStyleRule, nsIStyleSheet *aNewStyleRule) { } static void NSAPI nsDocumentObserver_StyleRuleAdded(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule) { } static void NSAPI nsDocumentObserver_StyleRuleRemoved(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIStyleSheet *aStyleSheet, nsIStyleRule *aStyleRule) { } static void NSAPI nsDocumentObserver_BindToDocument(nsIDocumentObserver *iface, nsIDocument *aDocument, nsIContent *aContent) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); nsIDOMHTMLIFrameElement *nsiframe; nsIDOMHTMLFrameElement *nsframe; nsIDOMHTMLScriptElement *nsscript; nsIDOMHTMLElement *nselem; nsIDOMComment *nscomment; nsresult nsres; TRACE("(%p)->(%p %p)\n", This, aDocument, aContent); nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLElement, (void**)&nselem); if(NS_SUCCEEDED(nsres)) { check_event_attr(This, nselem); nsIDOMHTMLElement_Release(nselem); } nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMComment, (void**)&nscomment); if(NS_SUCCEEDED(nsres)) { TRACE("comment node\n"); add_script_runner(This, run_insert_comment, (nsISupports*)nscomment, NULL); nsIDOMComment_Release(nscomment); return; } nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLIFrameElement, (void**)&nsiframe); if(NS_SUCCEEDED(nsres)) { TRACE("iframe node\n"); add_script_runner(This, run_bind_to_tree, (nsISupports*)nsiframe, NULL); nsIDOMHTMLIFrameElement_Release(nsiframe); return; } nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLFrameElement, (void**)&nsframe); if(NS_SUCCEEDED(nsres)) { TRACE("frame node\n"); add_script_runner(This, run_bind_to_tree, (nsISupports*)nsframe, NULL); nsIDOMHTMLFrameElement_Release(nsframe); return; } nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript); if(NS_SUCCEEDED(nsres)) { HTMLScriptElement *script_elem; HRESULT hres; TRACE("script element\n"); hres = script_elem_from_nsscript(This, nsscript, &script_elem); nsIDOMHTMLScriptElement_Release(nsscript); if(FAILED(hres)) return; if(script_elem->parse_on_bind) add_script_runner(This, run_insert_script, (nsISupports*)nsscript, NULL); IHTMLScriptElement_Release(&script_elem->IHTMLScriptElement_iface); } } static void NSAPI nsDocumentObserver_AttemptToExecuteScript(nsIDocumentObserver *iface, nsIContent *aContent, nsIParser *aParser, cpp_bool *aBlock) { HTMLDocumentNode *This = impl_from_nsIDocumentObserver(iface); nsIDOMHTMLScriptElement *nsscript; nsresult nsres; TRACE("(%p)->(%p %p %p)\n", This, aContent, aParser, aBlock); nsres = nsIContent_QueryInterface(aContent, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript); if(NS_SUCCEEDED(nsres)) { TRACE("script node\n"); add_script_runner(This, run_insert_script, (nsISupports*)nsscript, (nsISupports*)aParser); nsIDOMHTMLScriptElement_Release(nsscript); } } static const nsIDocumentObserverVtbl nsDocumentObserverVtbl = { nsDocumentObserver_QueryInterface, nsDocumentObserver_AddRef, nsDocumentObserver_Release, nsDocumentObserver_CharacterDataWillChange, nsDocumentObserver_CharacterDataChanged, nsDocumentObserver_AttributeWillChange, nsDocumentObserver_AttributeChanged, nsDocumentObserver_AttributeSetToCurrentValue, nsDocumentObserver_ContentAppended, nsDocumentObserver_ContentInserted, nsDocumentObserver_ContentRemoved, nsDocumentObserver_NodeWillBeDestroyed, nsDocumentObserver_ParentChainChanged, nsDocumentObserver_BeginUpdate, nsDocumentObserver_EndUpdate, nsDocumentObserver_BeginLoad, nsDocumentObserver_EndLoad, nsDocumentObserver_ContentStatesChanged, nsDocumentObserver_DocumentStatesChanged, nsDocumentObserver_StyleSheetAdded, nsDocumentObserver_StyleSheetRemoved, nsDocumentObserver_StyleSheetApplicableStateChanged, nsDocumentObserver_StyleRuleChanged, nsDocumentObserver_StyleRuleAdded, nsDocumentObserver_StyleRuleRemoved, nsDocumentObserver_BindToDocument, nsDocumentObserver_AttemptToExecuteScript }; void init_document_mutation(HTMLDocumentNode *doc) { nsIDocument *nsdoc; nsresult nsres; doc->nsIDocumentObserver_iface.lpVtbl = &nsDocumentObserverVtbl; nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc); if(NS_FAILED(nsres)) { ERR("Could not get nsIDocument: %08x\n", nsres); return; } nsIContentUtils_AddDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface); nsIDocument_Release(nsdoc); } void release_document_mutation(HTMLDocumentNode *doc) { nsIDocument *nsdoc; nsresult nsres; nsres = nsIDOMHTMLDocument_QueryInterface(doc->nsdoc, &IID_nsIDocument, (void**)&nsdoc); if(NS_FAILED(nsres)) { ERR("Could not get nsIDocument: %08x\n", nsres); return; } nsIContentUtils_RemoveDocumentObserver(content_utils, nsdoc, &doc->nsIDocumentObserver_iface); nsIDocument_Release(nsdoc); } JSContext *get_context_from_document(nsIDOMHTMLDocument *nsdoc) { nsIDocument *doc; JSContext *ctx; nsresult nsres; nsres = nsIDOMHTMLDocument_QueryInterface(nsdoc, &IID_nsIDocument, (void**)&doc); assert(nsres == NS_OK); ctx = nsIContentUtils_GetContextFromDocument(content_utils, doc); nsIDocument_Release(doc); TRACE("ret %p\n", ctx); return ctx; } void init_mutation(nsIComponentManager *component_manager) { nsIFactory *factory; nsresult nsres; if(!component_manager) { if(content_utils) { nsIContentUtils_Release(content_utils); content_utils = NULL; } return; } nsres = nsIComponentManager_GetClassObject(component_manager, &NS_ICONTENTUTILS_CID, &IID_nsIFactory, (void**)&factory); if(NS_FAILED(nsres)) { ERR("Could not create nsIContentUtils service: %08x\n", nsres); return; } nsres = nsIFactory_CreateInstance(factory, NULL, &IID_nsIContentUtils, (void**)&content_utils); nsIFactory_Release(factory); if(NS_FAILED(nsres)) ERR("Could not create nsIContentUtils instance: %08x\n", nsres); }