dlls/mshtml/script.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 <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27 #include "activscp.h"
  28 #include "activdbg.h"
  29 #include "shlwapi.h"
  30
  31 #include "wine/debug.h"
  32
  33 #include "mshtml_private.h"
  34 #include "htmlscript.h"
  35 #include "pluginhost.h"
  36 #include "htmlevent.h"
  37 #include "binding.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  40
  41 #ifdef _WIN64
  42
  43 #define CTXARG_T DWORDLONG
  44 #define IActiveScriptSiteDebugVtbl IActiveScriptSiteDebug64Vtbl
  45
  46 #define IActiveScriptParse_Release IActiveScriptParse64_Release
  47 #define IActiveScriptParse_InitNew IActiveScriptParse64_InitNew
  48 #define IActiveScriptParse_ParseScriptText IActiveScriptParse64_ParseScriptText
  49 #define IActiveScriptParseProcedure2_Release IActiveScriptParseProcedure2_64_Release
  50 #define IActiveScriptParseProcedure2_ParseProcedureText IActiveScriptParseProcedure2_64_ParseProcedureText
  51
  52 #else
  53
  54 #define CTXARG_T DWORD
  55 #define IActiveScriptSiteDebugVtbl IActiveScriptSiteDebug32Vtbl
  56
  57 #define IActiveScriptParse_Release IActiveScriptParse32_Release
  58 #define IActiveScriptParse_InitNew IActiveScriptParse32_InitNew
  59 #define IActiveScriptParse_ParseScriptText IActiveScriptParse32_ParseScriptText
  60 #define IActiveScriptParseProcedure2_Release IActiveScriptParseProcedure2_32_Release
  61 #define IActiveScriptParseProcedure2_ParseProcedureText IActiveScriptParseProcedure2_32_ParseProcedureText
  62
  63 #endif
  64
  65 /* See jscript.h in jscript.dll. */
  66 #define SCRIPTLANGUAGEVERSION_HTML 0x400
  67 #define SCRIPTLANGUAGEVERSION_ES5  0x102
  68 #define SCRIPTLANGUAGEVERSION_ES6  0x103
  69
  70 struct ScriptHost {
  71     IActiveScriptSite              IActiveScriptSite_iface;
  72     IActiveScriptSiteInterruptPoll IActiveScriptSiteInterruptPoll_iface;
  73     IActiveScriptSiteWindow        IActiveScriptSiteWindow_iface;
  74     IActiveScriptSiteUIControl     IActiveScriptSiteUIControl_iface;
  75     IActiveScriptSiteDebug         IActiveScriptSiteDebug_iface;
  76     IServiceProvider               IServiceProvider_iface;
  77
  78     LONG ref;
  79
  80     IActiveScript *script;
  81     IActiveScriptParse *parse;
  82     IActiveScriptParseProcedure2 *parse_proc;
  83
  84     SCRIPTSTATE script_state;
  85
  86     HTMLInnerWindow *window;
  87
  88     GUID guid;
  89     struct list entry;
  90 };
  91
  92 static ScriptHost *get_elem_script_host(HTMLInnerWindow*,HTMLScriptElement*);
  93
  94 static BOOL set_script_prop(ScriptHost *script_host, DWORD property, VARIANT *val)
  95 {
  96     IActiveScriptProperty *script_prop;
  97     HRESULT hres;
  98
  99     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptProperty,
 100             (void**)&script_prop);
 101     if(FAILED(hres)) {
 102         WARN("Could not get IActiveScriptProperty iface: %08lx\n", hres);
 103         return FALSE;
 104     }
 105
 106     hres = IActiveScriptProperty_SetProperty(script_prop, property, NULL, val);
 107     IActiveScriptProperty_Release(script_prop);
 108     if(FAILED(hres)) {
 109         WARN("SetProperty(%lx) failed: %08lx\n", property, hres);
 110         return FALSE;
 111     }
 112
 113     return TRUE;
 114 }
 115
 116 static BOOL init_script_engine(ScriptHost *script_host)
 117 {
 118     compat_mode_t compat_mode;
 119     IObjectSafety *safety;
 120     SCRIPTSTATE state;
 121     DWORD supported_opts=0, enabled_opts=0, script_mode;
 122     VARIANT var;
 123     HRESULT hres;
 124
 125     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptParse, (void**)&script_host->parse);
 126     if(FAILED(hres)) {
 127         WARN("Could not get IActiveScriptParse: %08lx\n", hres);
 128         return FALSE;
 129     }
 130
 131     hres = IActiveScript_QueryInterface(script_host->script, &IID_IObjectSafety, (void**)&safety);
 132     if(FAILED(hres)) {
 133         FIXME("Could not get IObjectSafety: %08lx\n", hres);
 134         return FALSE;
 135     }
 136
 137     hres = IObjectSafety_GetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse, &supported_opts, &enabled_opts);
 138     if(FAILED(hres)) {
 139         FIXME("GetInterfaceSafetyOptions failed: %08lx\n", hres);
 140     }else if(!(supported_opts & INTERFACE_USES_DISPEX)) {
 141         FIXME("INTERFACE_USES_DISPEX is not supported\n");
 142     }else {
 143         hres = IObjectSafety_SetInterfaceSafetyOptions(safety, &IID_IActiveScriptParse,
 144                 INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER,
 145                 INTERFACESAFE_FOR_UNTRUSTED_DATA|INTERFACE_USES_DISPEX|INTERFACE_USES_SECURITY_MANAGER);
 146         if(FAILED(hres))
 147             FIXME("SetInterfaceSafetyOptions failed: %08lx\n", hres);
 148     }
 149
 150     IObjectSafety_Release(safety);
 151     if(FAILED(hres))
 152         return FALSE;
 153
 154     compat_mode = lock_document_mode(script_host->window->doc);
 155     script_mode = compat_mode < COMPAT_MODE_IE8 ? SCRIPTLANGUAGEVERSION_5_7 : SCRIPTLANGUAGEVERSION_5_8;
 156     if(IsEqualGUID(&script_host->guid, &CLSID_JScript)) {
 157         if(compat_mode >= COMPAT_MODE_IE11)
 158             script_mode = SCRIPTLANGUAGEVERSION_ES6;
 159         else if(compat_mode >= COMPAT_MODE_IE9)
 160             script_mode = SCRIPTLANGUAGEVERSION_ES5;
 161         script_mode |= SCRIPTLANGUAGEVERSION_HTML;
 162     }
 163     V_VT(&var) = VT_I4;
 164     V_I4(&var) = script_mode;
 165     if(!set_script_prop(script_host, SCRIPTPROP_INVOKEVERSIONING, &var) && (script_mode & SCRIPTLANGUAGEVERSION_HTML)) {
 166         /* If this failed, we're most likely using native jscript. */
 167         WARN("Failed to set script mode to HTML version.\n");
 168         V_I4(&var) = compat_mode < COMPAT_MODE_IE8 ? SCRIPTLANGUAGEVERSION_5_7 : SCRIPTLANGUAGEVERSION_5_8;
 169         set_script_prop(script_host, SCRIPTPROP_INVOKEVERSIONING, &var);
 170     }
 171
 172     V_VT(&var) = VT_BOOL;
 173     V_BOOL(&var) = VARIANT_TRUE;
 174     set_script_prop(script_host, SCRIPTPROP_HACK_TRIDENTEVENTSINK, &var);
 175
 176     hres = IActiveScriptParse_InitNew(script_host->parse);
 177     if(FAILED(hres)) {
 178         WARN("InitNew failed: %08lx\n", hres);
 179         return FALSE;
 180     }
 181
 182     hres = IActiveScript_SetScriptSite(script_host->script, &script_host->IActiveScriptSite_iface);
 183     if(FAILED(hres)) {
 184         WARN("SetScriptSite failed: %08lx\n", hres);
 185         IActiveScript_Close(script_host->script);
 186         return FALSE;
 187     }
 188
 189     hres = IActiveScript_GetScriptState(script_host->script, &state);
 190     if(FAILED(hres))
 191         WARN("GetScriptState failed: %08lx\n", hres);
 192     else if(state != SCRIPTSTATE_INITIALIZED)
 193         FIXME("state = %x\n", state);
 194
 195     hres = IActiveScript_SetScriptState(script_host->script, SCRIPTSTATE_STARTED);
 196     if(FAILED(hres)) {
 197         WARN("Starting script failed: %08lx\n", hres);
 198         return FALSE;
 199     }
 200
 201     hres = IActiveScript_AddNamedItem(script_host->script, L"window",
 202             SCRIPTITEM_ISVISIBLE|SCRIPTITEM_ISSOURCE|SCRIPTITEM_GLOBALMEMBERS);
 203     if(SUCCEEDED(hres)) {
 204         V_VT(&var) = VT_BOOL;
 205         V_BOOL(&var) = VARIANT_TRUE;
 206         set_script_prop(script_host, SCRIPTPROP_ABBREVIATE_GLOBALNAME_RESOLUTION, &var);
 207     }else {
 208        WARN("AddNamedItem failed: %08lx\n", hres);
 209     }
 210
 211     hres = IActiveScript_QueryInterface(script_host->script, &IID_IActiveScriptParseProcedure2,
 212                                         (void**)&script_host->parse_proc);
 213     if(FAILED(hres)) {
 214         /* FIXME: QI for IActiveScriptParseProcedure */
 215         WARN("Could not get IActiveScriptParseProcedure iface: %08lx\n", hres);
 216     }
 217
 218     return TRUE;
 219 }
 220
 221 static void release_script_engine(ScriptHost *This)
 222 {
 223     if(!This->script)
 224         return;
 225
 226     switch(This->script_state) {
 227     case SCRIPTSTATE_CONNECTED:
 228         IActiveScript_SetScriptState(This->script, SCRIPTSTATE_DISCONNECTED);
 229
 230     case SCRIPTSTATE_STARTED:
 231     case SCRIPTSTATE_DISCONNECTED:
 232     case SCRIPTSTATE_INITIALIZED:
 233         IActiveScript_Close(This->script);
 234
 235     default:
 236         if(This->parse_proc) {
 237             IActiveScriptParseProcedure2_Release(This->parse_proc);
 238             This->parse_proc = NULL;
 239         }
 240
 241         if(This->parse) {
 242             IActiveScriptParse_Release(This->parse);
 243             This->parse = NULL;
 244         }
 245     }
 246
 247     IActiveScript_Release(This->script);
 248     This->script = NULL;
 249     This->script_state = SCRIPTSTATE_UNINITIALIZED;
 250 }
 251
 252 void connect_scripts(HTMLInnerWindow *window)
 253 {
 254     ScriptHost *iter;
 255
 256     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
 257         if(iter->script_state == SCRIPTSTATE_STARTED)
 258             IActiveScript_SetScriptState(iter->script, SCRIPTSTATE_CONNECTED);
 259     }
 260 }
 261
 262 static inline ScriptHost *impl_from_IActiveScriptSite(IActiveScriptSite *iface)
 263 {
 264     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSite_iface);
 265 }
 266
 267 static HRESULT WINAPI ActiveScriptSite_QueryInterface(IActiveScriptSite *iface, REFIID riid, void **ppv)
 268 {
 269     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 270
 271     *ppv = NULL;
 272
 273     if(IsEqualGUID(&IID_IUnknown, riid)) {
 274         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 275         *ppv = &This->IActiveScriptSite_iface;
 276     }else if(IsEqualGUID(&IID_IActiveScriptSite, riid)) {
 277         TRACE("(%p)->(IID_IActiveScriptSite %p)\n", This, ppv);
 278         *ppv = &This->IActiveScriptSite_iface;
 279     }else if(IsEqualGUID(&IID_IActiveScriptSiteInterruptPoll, riid)) {
 280         TRACE("(%p)->(IID_IActiveScriptSiteInterruprtPoll %p)\n", This, ppv);
 281         *ppv = &This->IActiveScriptSiteInterruptPoll_iface;
 282     }else if(IsEqualGUID(&IID_IActiveScriptSiteWindow, riid)) {
 283         TRACE("(%p)->(IID_IActiveScriptSiteWindow %p)\n", This, ppv);
 284         *ppv = &This->IActiveScriptSiteWindow_iface;
 285     }else if(IsEqualGUID(&IID_IActiveScriptSiteUIControl, riid)) {
 286         TRACE("(%p)->(IID_IActiveScriptSiteUIControl %p)\n", This, ppv);
 287         *ppv = &This->IActiveScriptSiteUIControl_iface;
 288     }else if(IsEqualGUID(&IID_IActiveScriptSiteDebug, riid)) {
 289         TRACE("(%p)->(IID_IActiveScriptSiteDebug %p)\n", This, ppv);
 290         *ppv = &This->IActiveScriptSiteDebug_iface;
 291     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 292         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 293         *ppv = &This->IServiceProvider_iface;
 294     }else if(IsEqualGUID(&IID_ICanHandleException, riid)) {
 295         TRACE("(%p)->(IID_ICanHandleException not supported %p)\n", This, ppv);
 296         return E_NOINTERFACE;
 297     }else {
 298         FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 299         return E_NOINTERFACE;
 300     }
 301
 302     IUnknown_AddRef((IUnknown*)*ppv);
 303     return S_OK;
 304 }
 305
 306 static ULONG WINAPI ActiveScriptSite_AddRef(IActiveScriptSite *iface)
 307 {
 308     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 309     LONG ref = InterlockedIncrement(&This->ref);
 310
 311     TRACE("(%p) ref=%ld\n", This, ref);
 312
 313     return ref;
 314 }
 315
 316 static ULONG WINAPI ActiveScriptSite_Release(IActiveScriptSite *iface)
 317 {
 318     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 319     LONG ref = InterlockedDecrement(&This->ref);
 320
 321     TRACE("(%p) ref=%ld\n", This, ref);
 322
 323     if(!ref) {
 324         release_script_engine(This);
 325         if(This->window)
 326             list_remove(&This->entry);
 327         heap_free(This);
 328     }
 329
 330     return ref;
 331 }
 332
 333 static HRESULT WINAPI ActiveScriptSite_GetLCID(IActiveScriptSite *iface, LCID *plcid)
 334 {
 335     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 336
 337     TRACE("(%p)->(%p)\n", This, plcid);
 338
 339     *plcid = GetUserDefaultLCID();
 340     return S_OK;
 341 }
 342
 343 static HRESULT WINAPI ActiveScriptSite_GetItemInfo(IActiveScriptSite *iface, LPCOLESTR pstrName,
 344         DWORD dwReturnMask, IUnknown **ppiunkItem, ITypeInfo **ppti)
 345 {
 346     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 347
 348     TRACE("(%p)->(%s %lx %p %p)\n", This, debugstr_w(pstrName), dwReturnMask, ppiunkItem, ppti);
 349
 350     if(dwReturnMask != SCRIPTINFO_IUNKNOWN) {
 351         FIXME("Unsupported mask %lx\n", dwReturnMask);
 352         return E_NOTIMPL;
 353     }
 354
 355     *ppiunkItem = NULL;
 356
 357     if(wcscmp(pstrName, L"window"))
 358         return DISP_E_MEMBERNOTFOUND;
 359
 360     if(!This->window)
 361         return E_FAIL;
 362
 363     /* FIXME: Return proxy object */
 364     *ppiunkItem = (IUnknown*)&This->window->base.IHTMLWindow2_iface;
 365     IUnknown_AddRef(*ppiunkItem);
 366
 367     return S_OK;
 368 }
 369
 370 static HRESULT WINAPI ActiveScriptSite_GetDocVersionString(IActiveScriptSite *iface, BSTR *pbstrVersion)
 371 {
 372     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 373     FIXME("(%p)->(%p)\n", This, pbstrVersion);
 374     return E_NOTIMPL;
 375 }
 376
 377 static HRESULT WINAPI ActiveScriptSite_OnScriptTerminate(IActiveScriptSite *iface,
 378         const VARIANT *pvarResult, const EXCEPINFO *pexcepinfo)
 379 {
 380     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 381     FIXME("(%p)->(%p %p)\n", This, pvarResult, pexcepinfo);
 382     return E_NOTIMPL;
 383 }
 384
 385 static HRESULT WINAPI ActiveScriptSite_OnStateChange(IActiveScriptSite *iface, SCRIPTSTATE ssScriptState)
 386 {
 387     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 388
 389     TRACE("(%p)->(%x)\n", This, ssScriptState);
 390
 391     This->script_state = ssScriptState;
 392     return S_OK;
 393 }
 394
 395 static HRESULT WINAPI ActiveScriptSite_OnScriptError(IActiveScriptSite *iface, IActiveScriptError *pscripterror)
 396 {
 397     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 398     FIXME("(%p)->(%p)\n", This, pscripterror);
 399     return E_NOTIMPL;
 400 }
 401
 402 static HRESULT WINAPI ActiveScriptSite_OnEnterScript(IActiveScriptSite *iface)
 403 {
 404     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 405
 406     TRACE("(%p)->()\n", This);
 407
 408     return S_OK;
 409 }
 410
 411 static HRESULT WINAPI ActiveScriptSite_OnLeaveScript(IActiveScriptSite *iface)
 412 {
 413     ScriptHost *This = impl_from_IActiveScriptSite(iface);
 414
 415     TRACE("(%p)->()\n", This);
 416
 417     return S_OK;
 418 }
 419
 420 static const IActiveScriptSiteVtbl ActiveScriptSiteVtbl = {
 421     ActiveScriptSite_QueryInterface,
 422     ActiveScriptSite_AddRef,
 423     ActiveScriptSite_Release,
 424     ActiveScriptSite_GetLCID,
 425     ActiveScriptSite_GetItemInfo,
 426     ActiveScriptSite_GetDocVersionString,
 427     ActiveScriptSite_OnScriptTerminate,
 428     ActiveScriptSite_OnStateChange,
 429     ActiveScriptSite_OnScriptError,
 430     ActiveScriptSite_OnEnterScript,
 431     ActiveScriptSite_OnLeaveScript
 432 };
 433
 434 static inline ScriptHost *impl_from_IActiveScriptSiteInterruptPoll(IActiveScriptSiteInterruptPoll *iface)
 435 {
 436     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteInterruptPoll_iface);
 437 }
 438
 439 static HRESULT WINAPI ActiveScriptSiteInterruptPoll_QueryInterface(IActiveScriptSiteInterruptPoll *iface,
 440         REFIID riid, void **ppv)
 441 {
 442     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 443     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 444 }
 445
 446 static ULONG WINAPI ActiveScriptSiteInterruptPoll_AddRef(IActiveScriptSiteInterruptPoll *iface)
 447 {
 448     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 449     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 450 }
 451
 452 static ULONG WINAPI ActiveScriptSiteInterruptPoll_Release(IActiveScriptSiteInterruptPoll *iface)
 453 {
 454     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 455     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 456 }
 457
 458 static HRESULT WINAPI ActiveScriptSiteInterruptPoll_QueryContinue(IActiveScriptSiteInterruptPoll *iface)
 459 {
 460     ScriptHost *This = impl_from_IActiveScriptSiteInterruptPoll(iface);
 461
 462     TRACE("(%p)\n", This);
 463
 464     return S_OK;
 465 }
 466
 467 static const IActiveScriptSiteInterruptPollVtbl ActiveScriptSiteInterruptPollVtbl = {
 468     ActiveScriptSiteInterruptPoll_QueryInterface,
 469     ActiveScriptSiteInterruptPoll_AddRef,
 470     ActiveScriptSiteInterruptPoll_Release,
 471     ActiveScriptSiteInterruptPoll_QueryContinue
 472 };
 473
 474 static inline ScriptHost *impl_from_IActiveScriptSiteWindow(IActiveScriptSiteWindow *iface)
 475 {
 476     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteWindow_iface);
 477 }
 478
 479 static HRESULT WINAPI ActiveScriptSiteWindow_QueryInterface(IActiveScriptSiteWindow *iface,
 480         REFIID riid, void **ppv)
 481 {
 482     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 483     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 484 }
 485
 486 static ULONG WINAPI ActiveScriptSiteWindow_AddRef(IActiveScriptSiteWindow *iface)
 487 {
 488     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 489     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 490 }
 491
 492 static ULONG WINAPI ActiveScriptSiteWindow_Release(IActiveScriptSiteWindow *iface)
 493 {
 494     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 495     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 496 }
 497
 498 static HRESULT WINAPI ActiveScriptSiteWindow_GetWindow(IActiveScriptSiteWindow *iface, HWND *phwnd)
 499 {
 500     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 501
 502     TRACE("(%p)->(%p)\n", This, phwnd);
 503
 504     if(!This->window || !This->window->base.outer_window)
 505         return E_UNEXPECTED;
 506
 507     *phwnd = This->window->base.outer_window->browser->doc->hwnd;
 508     return S_OK;
 509 }
 510
 511 static HRESULT WINAPI ActiveScriptSiteWindow_EnableModeless(IActiveScriptSiteWindow *iface, BOOL fEnable)
 512 {
 513     ScriptHost *This = impl_from_IActiveScriptSiteWindow(iface);
 514     FIXME("(%p)->(%x)\n", This, fEnable);
 515     return S_OK;
 516 }
 517
 518 static const IActiveScriptSiteWindowVtbl ActiveScriptSiteWindowVtbl = {
 519     ActiveScriptSiteWindow_QueryInterface,
 520     ActiveScriptSiteWindow_AddRef,
 521     ActiveScriptSiteWindow_Release,
 522     ActiveScriptSiteWindow_GetWindow,
 523     ActiveScriptSiteWindow_EnableModeless
 524 };
 525
 526 static inline ScriptHost *impl_from_IActiveScriptSiteUIControl(IActiveScriptSiteUIControl *iface)
 527 {
 528     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteUIControl_iface);
 529 }
 530
 531 static HRESULT WINAPI ActiveScriptSiteUIControl_QueryInterface(IActiveScriptSiteUIControl *iface, REFIID riid, void **ppv)
 532 {
 533     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 534     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 535 }
 536
 537 static ULONG WINAPI ActiveScriptSiteUIControl_AddRef(IActiveScriptSiteUIControl *iface)
 538 {
 539     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 540     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 541 }
 542
 543 static ULONG WINAPI ActiveScriptSiteUIControl_Release(IActiveScriptSiteUIControl *iface)
 544 {
 545     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 546     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 547 }
 548
 549 static HRESULT WINAPI ActiveScriptSiteUIControl_GetUIBehavior(IActiveScriptSiteUIControl *iface, SCRIPTUICITEM UicItem,
 550         SCRIPTUICHANDLING *pUicHandling)
 551 {
 552     ScriptHost *This = impl_from_IActiveScriptSiteUIControl(iface);
 553
 554     WARN("(%p)->(%d %p) semi-stub\n", This, UicItem, pUicHandling);
 555
 556     *pUicHandling = SCRIPTUICHANDLING_ALLOW;
 557     return S_OK;
 558 }
 559
 560 static const IActiveScriptSiteUIControlVtbl ActiveScriptSiteUIControlVtbl = {
 561     ActiveScriptSiteUIControl_QueryInterface,
 562     ActiveScriptSiteUIControl_AddRef,
 563     ActiveScriptSiteUIControl_Release,
 564     ActiveScriptSiteUIControl_GetUIBehavior
 565 };
 566
 567 static inline ScriptHost *impl_from_IActiveScriptSiteDebug(IActiveScriptSiteDebug *iface)
 568 {
 569     return CONTAINING_RECORD(iface, ScriptHost, IActiveScriptSiteDebug_iface);
 570 }
 571
 572 static HRESULT WINAPI ActiveScriptSiteDebug_QueryInterface(IActiveScriptSiteDebug *iface,
 573         REFIID riid, void **ppv)
 574 {
 575     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 576     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 577 }
 578
 579 static ULONG WINAPI ActiveScriptSiteDebug_AddRef(IActiveScriptSiteDebug *iface)
 580 {
 581     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 582     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 583 }
 584
 585 static ULONG WINAPI ActiveScriptSiteDebug_Release(IActiveScriptSiteDebug *iface)
 586 {
 587     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 588     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 589 }
 590
 591 static HRESULT WINAPI ActiveScriptSiteDebug_GetDocumentContextFromPosition(IActiveScriptSiteDebug *iface,
 592             CTXARG_T dwSourceContext, ULONG uCharacterOffset, ULONG uNumChars, IDebugDocumentContext **ppsc)
 593 {
 594     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 595     FIXME("(%p)->(%s %lu %lu %p)\n", This, wine_dbgstr_longlong(dwSourceContext), uCharacterOffset,
 596           uNumChars, ppsc);
 597     return E_NOTIMPL;
 598 }
 599
 600 static HRESULT WINAPI ActiveScriptSiteDebug_GetApplication(IActiveScriptSiteDebug *iface, IDebugApplication **ppda)
 601 {
 602     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 603     FIXME("(%p)->(%p)\n", This, ppda);
 604     return E_NOTIMPL;
 605 }
 606
 607 static HRESULT WINAPI ActiveScriptSiteDebug_GetRootApplicationNode(IActiveScriptSiteDebug *iface,
 608             IDebugApplicationNode **ppdanRoot)
 609 {
 610     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 611     FIXME("(%p)->(%p)\n", This, ppdanRoot);
 612     return E_NOTIMPL;
 613 }
 614
 615 static HRESULT WINAPI ActiveScriptSiteDebug_OnScriptErrorDebug(IActiveScriptSiteDebug *iface,
 616             IActiveScriptErrorDebug *pErrorDebug, BOOL *pfEnterDebugger, BOOL *pfCallOnScriptErrorWhenContinuing)
 617 {
 618     ScriptHost *This = impl_from_IActiveScriptSiteDebug(iface);
 619     FIXME("(%p)->(%p %p %p)\n", This, pErrorDebug, pfEnterDebugger, pfCallOnScriptErrorWhenContinuing);
 620     return E_NOTIMPL;
 621 }
 622
 623 static const IActiveScriptSiteDebugVtbl ActiveScriptSiteDebugVtbl = {
 624     ActiveScriptSiteDebug_QueryInterface,
 625     ActiveScriptSiteDebug_AddRef,
 626     ActiveScriptSiteDebug_Release,
 627     ActiveScriptSiteDebug_GetDocumentContextFromPosition,
 628     ActiveScriptSiteDebug_GetApplication,
 629     ActiveScriptSiteDebug_GetRootApplicationNode,
 630     ActiveScriptSiteDebug_OnScriptErrorDebug
 631 };
 632
 633 static inline ScriptHost *impl_from_IServiceProvider(IServiceProvider *iface)
 634 {
 635     return CONTAINING_RECORD(iface, ScriptHost, IServiceProvider_iface);
 636 }
 637
 638 static HRESULT WINAPI ASServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 639 {
 640     ScriptHost *This = impl_from_IServiceProvider(iface);
 641     return IActiveScriptSite_QueryInterface(&This->IActiveScriptSite_iface, riid, ppv);
 642 }
 643
 644 static ULONG WINAPI ASServiceProvider_AddRef(IServiceProvider *iface)
 645 {
 646     ScriptHost *This = impl_from_IServiceProvider(iface);
 647     return IActiveScriptSite_AddRef(&This->IActiveScriptSite_iface);
 648 }
 649
 650 static ULONG WINAPI ASServiceProvider_Release(IServiceProvider *iface)
 651 {
 652     ScriptHost *This = impl_from_IServiceProvider(iface);
 653     return IActiveScriptSite_Release(&This->IActiveScriptSite_iface);
 654 }
 655
 656 static HRESULT WINAPI ASServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
 657         REFIID riid, void **ppv)
 658 {
 659     ScriptHost *This = impl_from_IServiceProvider(iface);
 660
 661     if(IsEqualGUID(&SID_SInternetHostSecurityManager, guidService)) {
 662         TRACE("(%p)->(SID_SInternetHostSecurityManager)\n", This);
 663
 664         if(!This->window || !This->window->doc)
 665             return E_NOINTERFACE;
 666
 667         return IInternetHostSecurityManager_QueryInterface(&This->window->doc->IInternetHostSecurityManager_iface,
 668                 riid, ppv);
 669     }
 670
 671     if(IsEqualGUID(&SID_SContainerDispatch, guidService)) {
 672         TRACE("(%p)->(SID_SContainerDispatch)\n", This);
 673
 674         if(!This->window || !This->window->doc)
 675             return E_NOINTERFACE;
 676
 677         return IHTMLDocument2_QueryInterface(&This->window->doc->basedoc.IHTMLDocument2_iface, riid, ppv);
 678     }
 679
 680     FIXME("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 681     return E_NOINTERFACE;
 682 }
 683
 684 static const IServiceProviderVtbl ASServiceProviderVtbl = {
 685     ASServiceProvider_QueryInterface,
 686     ASServiceProvider_AddRef,
 687     ASServiceProvider_Release,
 688     ASServiceProvider_QueryService
 689 };
 690
 691 static ScriptHost *create_script_host(HTMLInnerWindow *window, const GUID *guid)
 692 {
 693     ScriptHost *ret;
 694     HRESULT hres;
 695
 696     ret = heap_alloc_zero(sizeof(*ret));
 697     if(!ret)
 698         return NULL;
 699
 700     ret->IActiveScriptSite_iface.lpVtbl = &ActiveScriptSiteVtbl;
 701     ret->IActiveScriptSiteInterruptPoll_iface.lpVtbl = &ActiveScriptSiteInterruptPollVtbl;
 702     ret->IActiveScriptSiteWindow_iface.lpVtbl = &ActiveScriptSiteWindowVtbl;
 703     ret->IActiveScriptSiteUIControl_iface.lpVtbl = &ActiveScriptSiteUIControlVtbl;
 704     ret->IActiveScriptSiteDebug_iface.lpVtbl = &ActiveScriptSiteDebugVtbl;
 705     ret->IServiceProvider_iface.lpVtbl = &ASServiceProviderVtbl;
 706     ret->ref = 1;
 707     ret->window = window;
 708     ret->script_state = SCRIPTSTATE_UNINITIALIZED;
 709
 710     ret->guid = *guid;
 711     list_add_tail(&window->script_hosts, &ret->entry);
 712
 713     hres = CoCreateInstance(&ret->guid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 714             &IID_IActiveScript, (void**)&ret->script);
 715     if(FAILED(hres))
 716         WARN("Could not load script engine: %08lx\n", hres);
 717     else if(!init_script_engine(ret))
 718         release_script_engine(ret);
 719
 720     return ret;
 721 }
 722
 723 static void dispatch_script_readystatechange_event(HTMLScriptElement *script)
 724 {
 725     DOMEvent *event;
 726     HRESULT hres;
 727
 728     if(script->readystate != READYSTATE_LOADED ||
 729        dispex_compat_mode(&script->element.node.event_target.dispex) < COMPAT_MODE_IE10) {
 730         hres = create_document_event(script->element.node.doc, EVENTID_READYSTATECHANGE, &event);
 731         if(SUCCEEDED(hres)) {
 732             dispatch_event(&script->element.node.event_target, event);
 733             IDOMEvent_Release(&event->IDOMEvent_iface);
 734         }
 735     }
 736
 737     if(script->readystate == READYSTATE_LOADED) {
 738         hres = create_document_event(script->element.node.doc, EVENTID_LOAD, &event);
 739         if(SUCCEEDED(hres)) {
 740             dispatch_event(&script->element.node.event_target, event);
 741             IDOMEvent_Release(&event->IDOMEvent_iface);
 742         }
 743     }
 744 }
 745
 746 typedef struct {
 747     task_t header;
 748     HTMLScriptElement *elem;
 749 } fire_readystatechange_task_t;
 750
 751 static void fire_readystatechange_proc(task_t *_task)
 752 {
 753     fire_readystatechange_task_t *task = (fire_readystatechange_task_t*)_task;
 754
 755     if(!task->elem->pending_readystatechange_event)
 756         return;
 757
 758     task->elem->pending_readystatechange_event = FALSE;
 759     dispatch_script_readystatechange_event(task->elem);
 760 }
 761
 762 static void fire_readystatechange_task_destr(task_t *_task)
 763 {
 764     fire_readystatechange_task_t *task = (fire_readystatechange_task_t*)_task;
 765
 766     IHTMLScriptElement_Release(&task->elem->IHTMLScriptElement_iface);
 767 }
 768
 769 static void set_script_elem_readystate(HTMLScriptElement *script_elem, READYSTATE readystate)
 770 {
 771     script_elem->readystate = readystate;
 772
 773     if(readystate != READYSTATE_LOADED &&
 774        dispex_compat_mode(&script_elem->element.node.event_target.dispex) >= COMPAT_MODE_IE11)
 775         return;
 776
 777     if(readystate != READYSTATE_INTERACTIVE) {
 778         if(!script_elem->element.node.doc->window->parser_callback_cnt) {
 779             fire_readystatechange_task_t *task;
 780             HRESULT hres;
 781
 782             if(script_elem->pending_readystatechange_event)
 783                 return;
 784
 785             task = heap_alloc(sizeof(*task));
 786             if(!task)
 787                 return;
 788
 789             IHTMLScriptElement_AddRef(&script_elem->IHTMLScriptElement_iface);
 790             task->elem = script_elem;
 791
 792             hres = push_task(&task->header, fire_readystatechange_proc, fire_readystatechange_task_destr,
 793                     script_elem->element.node.doc->window->task_magic);
 794             if(SUCCEEDED(hres))
 795                 script_elem->pending_readystatechange_event = TRUE;
 796         }else {
 797             script_elem->pending_readystatechange_event = FALSE;
 798             dispatch_script_readystatechange_event(script_elem);
 799         }
 800     }
 801 }
 802
 803 static void parse_elem_text(ScriptHost *script_host, HTMLScriptElement *script_elem, LPCWSTR text)
 804 {
 805     EXCEPINFO excepinfo;
 806     VARIANT var;
 807     HRESULT hres;
 808
 809     TRACE("%s\n", debugstr_w(text));
 810
 811     VariantInit(&var);
 812     memset(&excepinfo, 0, sizeof(excepinfo));
 813     TRACE(">>>\n");
 814     hres = IActiveScriptParse_ParseScriptText(script_host->parse, text, L"window", NULL, L"</SCRIPT>",
 815                                               0, 0, SCRIPTTEXT_ISVISIBLE|SCRIPTTEXT_HOSTMANAGESSOURCE,
 816                                               &var, &excepinfo);
 817     if(SUCCEEDED(hres))
 818         TRACE("<<<\n");
 819     else
 820         WARN("<<< %08lx\n", hres);
 821 }
 822
 823 typedef struct {
 824     BSCallback bsc;
 825
 826     HTMLScriptElement *script_elem;
 827     nsILoadGroup *load_group;
 828     nsIRequest *request;
 829     DWORD scheme;
 830
 831     DWORD size;
 832     char *buf;
 833 } ScriptBSC;
 834
 835 static HRESULT get_binding_text(ScriptBSC *bsc, WCHAR **ret)
 836 {
 837     UINT cp = CP_UTF8;
 838     WCHAR *text;
 839
 840     if(!bsc->bsc.read) {
 841         text = heap_alloc(sizeof(WCHAR));
 842         if(!text)
 843             return E_OUTOFMEMORY;
 844         *text = 0;
 845         *ret = text;
 846         return S_OK;
 847     }
 848
 849     switch(bsc->bsc.bom) {
 850     case BOM_UTF16:
 851         if(bsc->bsc.read % sizeof(WCHAR)) {
 852             FIXME("The buffer is not a valid utf16 string\n");
 853             return E_FAIL;
 854         }
 855
 856         text = heap_alloc(bsc->bsc.read+sizeof(WCHAR));
 857         if(!text)
 858             return E_OUTOFMEMORY;
 859
 860         memcpy(text, bsc->buf, bsc->bsc.read);
 861         text[bsc->bsc.read/sizeof(WCHAR)] = 0;
 862         break;
 863
 864     default:
 865         /* FIXME: Try to use charset from HTTP headers first */
 866         cp = get_document_charset(bsc->script_elem->element.node.doc);
 867         /* fall through */
 868     case BOM_UTF8: {
 869         DWORD len;
 870
 871         len = MultiByteToWideChar(cp, 0, bsc->buf, bsc->bsc.read, NULL, 0);
 872         text = heap_alloc((len+1)*sizeof(WCHAR));
 873         if(!text)
 874             return E_OUTOFMEMORY;
 875
 876         MultiByteToWideChar(cp, 0, bsc->buf, bsc->bsc.read, text, len);
 877         text[len] = 0;
 878     }
 879     }
 880
 881     *ret = text;
 882     return S_OK;
 883 }
 884
 885 static void script_file_available(ScriptBSC *bsc)
 886 {
 887     HTMLScriptElement *script_elem = bsc->script_elem;
 888     HTMLInnerWindow *window = bsc->bsc.window;
 889     ScriptHost *script_host;
 890     nsIDOMNode *parent;
 891     nsresult nsres;
 892     HRESULT hres;
 893
 894     assert(window != NULL);
 895
 896     hres = get_binding_text(bsc, &script_elem->src_text);
 897     if(FAILED(hres))
 898         return;
 899
 900     script_host = get_elem_script_host(window, script_elem);
 901     if(!script_host)
 902         return;
 903
 904     if(window->parser_callback_cnt) {
 905         script_queue_entry_t *queue;
 906
 907         TRACE("Adding to queue\n");
 908
 909         queue = heap_alloc(sizeof(*queue));
 910         if(!queue)
 911             return;
 912
 913         IHTMLScriptElement_AddRef(&script_elem->IHTMLScriptElement_iface);
 914         queue->script = script_elem;
 915
 916         list_add_tail(&window->script_queue, &queue->entry);
 917         return;
 918     }
 919
 920     nsres = nsIDOMElement_GetParentNode(script_elem->element.dom_element, &parent);
 921     if(NS_FAILED(nsres) || !parent) {
 922         TRACE("No parent, not executing\n");
 923         script_elem->parse_on_bind = TRUE;
 924         return;
 925     }
 926
 927     nsIDOMNode_Release(parent);
 928
 929     script_host = get_elem_script_host(window, script_elem);
 930     if(!script_host)
 931         return;
 932
 933     script_elem->parsed = TRUE;
 934     if(script_host->parse)
 935         parse_elem_text(script_host, script_elem, script_elem->src_text);
 936 }
 937
 938 static inline ScriptBSC *impl_from_BSCallback(BSCallback *iface)
 939 {
 940     return CONTAINING_RECORD(iface, ScriptBSC, bsc);
 941 }
 942
 943 static void ScriptBSC_destroy(BSCallback *bsc)
 944 {
 945     ScriptBSC *This = impl_from_BSCallback(bsc);
 946
 947     if(This->script_elem) {
 948         IHTMLScriptElement_Release(&This->script_elem->IHTMLScriptElement_iface);
 949         This->script_elem = NULL;
 950     }
 951
 952     if(This->request) {
 953         ERR("Unfinished request\n");
 954         nsIRequest_Release(This->request);
 955     }
 956     if(This->load_group)
 957         nsILoadGroup_Release(This->load_group);
 958
 959     heap_free(This->buf);
 960     heap_free(This);
 961 }
 962
 963 static HRESULT ScriptBSC_init_bindinfo(BSCallback *bsc)
 964 {
 965     return S_OK;
 966 }
 967
 968 static HRESULT ScriptBSC_start_binding(BSCallback *bsc)
 969 {
 970     ScriptBSC *This = impl_from_BSCallback(bsc);
 971     nsresult nsres;
 972
 973     This->script_elem->binding = &This->bsc;
 974
 975     if(This->load_group) {
 976         nsres = create_onload_blocker_request(&This->request);
 977         if(NS_SUCCEEDED(nsres)) {
 978             nsres = nsILoadGroup_AddRequest(This->load_group, This->request, NULL);
 979             if(NS_FAILED(nsres))
 980                 ERR("AddRequest failed: %08lx\n", nsres);
 981         }
 982     }
 983
 984     /* FIXME: We should find a better to decide if 'loading' state is supposed to be used by the protocol. */
 985     if(This->scheme == URL_SCHEME_HTTPS || This->scheme == URL_SCHEME_HTTP)
 986         set_script_elem_readystate(This->script_elem, READYSTATE_LOADING);
 987
 988     return S_OK;
 989 }
 990
 991 static HRESULT ScriptBSC_stop_binding(BSCallback *bsc, HRESULT result)
 992 {
 993     ScriptBSC *This = impl_from_BSCallback(bsc);
 994     nsresult nsres;
 995
 996     if(SUCCEEDED(result) && !This->script_elem)
 997         result = E_UNEXPECTED;
 998
 999     assert(FAILED(result) || This->script_elem->binding == &This->bsc);
1000     This->script_elem->binding = NULL;
1001
1002     if(This->script_elem->readystate == READYSTATE_LOADING)
1003         set_script_elem_readystate(This->script_elem, READYSTATE_LOADED);
1004
1005     if(SUCCEEDED(result)) {
1006         script_file_available(This);
1007     }else {
1008         FIXME("binding failed %08lx\n", result);
1009         heap_free(This->buf);
1010         This->buf = NULL;
1011         This->size = 0;
1012     }
1013
1014     if(This->request) {
1015         nsres = nsILoadGroup_RemoveRequest(This->load_group, This->request, NULL, NS_OK);
1016         if(NS_FAILED(nsres))
1017             ERR("RemoveRequest failed: %08lx\n", nsres);
1018         nsIRequest_Release(This->request);
1019         This->request = NULL;
1020     }
1021
1022     IHTMLScriptElement_Release(&This->script_elem->IHTMLScriptElement_iface);
1023     This->script_elem = NULL;
1024     return S_OK;
1025 }
1026
1027 static HRESULT ScriptBSC_read_data(BSCallback *bsc, IStream *stream)
1028 {
1029     ScriptBSC *This = impl_from_BSCallback(bsc);
1030     DWORD read;
1031     HRESULT hres;
1032
1033     if(!This->buf) {
1034         This->buf = heap_alloc(128);
1035         if(!This->buf)
1036             return E_OUTOFMEMORY;
1037         This->size = 128;
1038     }
1039
1040     do {
1041         if(This->bsc.read >= This->size) {
1042             void *new_buf;
1043             new_buf = heap_realloc(This->buf, This->size << 1);
1044             if(!new_buf)
1045                 return E_OUTOFMEMORY;
1046             This->size <<= 1;
1047             This->buf = new_buf;
1048         }
1049
1050         hres = read_stream(&This->bsc, stream, This->buf+This->bsc.read, This->size-This->bsc.read, &read);
1051     }while(hres == S_OK);
1052
1053     return S_OK;
1054 }
1055
1056 static HRESULT ScriptBSC_on_progress(BSCallback *bsc, ULONG status_code, LPCWSTR status_text)
1057 {
1058     return S_OK;
1059 }
1060
1061 static HRESULT ScriptBSC_on_response(BSCallback *bsc, DWORD response_code,
1062         LPCWSTR response_headers)
1063 {
1064     return S_OK;
1065 }
1066
1067 static HRESULT ScriptBSC_beginning_transaction(BSCallback *bsc, WCHAR **additional_headers)
1068 {
1069     return S_FALSE;
1070 }
1071
1072 static const BSCallbackVtbl ScriptBSCVtbl = {
1073     ScriptBSC_destroy,
1074     ScriptBSC_init_bindinfo,
1075     ScriptBSC_start_binding,
1076     ScriptBSC_stop_binding,
1077     ScriptBSC_read_data,
1078     ScriptBSC_on_progress,
1079     ScriptBSC_on_response,
1080     ScriptBSC_beginning_transaction
1081 };
1082
1083
1084 HRESULT load_script(HTMLScriptElement *script_elem, const WCHAR *src, BOOL async)
1085 {
1086     HTMLInnerWindow *window;
1087     ScriptBSC *bsc;
1088     IMoniker *mon;
1089     IUri *uri;
1090     HRESULT hres;
1091
1092     static const WCHAR wine_schemaW[] = {'w','i','n','e',':'};
1093
1094     if(lstrlenW(src) > ARRAY_SIZE(wine_schemaW) && !memcmp(src, wine_schemaW, sizeof(wine_schemaW)))
1095         src += ARRAY_SIZE(wine_schemaW);
1096
1097     TRACE("(%p %s %x)\n", script_elem, debugstr_w(src), async);
1098
1099     if(!script_elem->element.node.doc || !(window = script_elem->element.node.doc->window)) {
1100         ERR("no window\n");
1101         return E_UNEXPECTED;
1102     }
1103
1104     hres = create_uri(src, 0, &uri);
1105     if(FAILED(hres))
1106         return hres;
1107
1108     hres = CreateURLMonikerEx2(NULL, uri, &mon, URL_MK_UNIFORM);
1109     if(FAILED(hres)) {
1110         IUri_Release(uri);
1111         return hres;
1112     }
1113
1114     bsc = heap_alloc_zero(sizeof(*bsc));
1115     if(!bsc) {
1116         IMoniker_Release(mon);
1117         IUri_Release(uri);
1118         return E_OUTOFMEMORY;
1119     }
1120
1121     init_bscallback(&bsc->bsc, &ScriptBSCVtbl, mon, async ? BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA : 0);
1122     IMoniker_Release(mon);
1123
1124     hres = IUri_GetScheme(uri, &bsc->scheme);
1125     IUri_Release(uri);
1126     if(FAILED(hres))
1127         bsc->scheme = URL_SCHEME_UNKNOWN;
1128
1129     IHTMLScriptElement_AddRef(&script_elem->IHTMLScriptElement_iface);
1130     bsc->script_elem = script_elem;
1131
1132     if(window->bscallback && window->bscallback->nschannel &&
1133        window->bscallback->nschannel->load_group) {
1134         cpp_bool contains;
1135         nsresult nsres;
1136
1137         nsres = nsIDOMNode_Contains(script_elem->element.node.doc->node.nsnode,
1138                                     script_elem->element.node.nsnode, &contains);
1139         if(NS_SUCCEEDED(nsres) && contains) {
1140             TRACE("script %p will block load event\n", script_elem);
1141             bsc->load_group = window->bscallback->nschannel->load_group;
1142             nsILoadGroup_AddRef(bsc->load_group);
1143         }
1144     }
1145
1146     hres = start_binding(window, &bsc->bsc, NULL);
1147
1148     IBindStatusCallback_Release(&bsc->bsc.IBindStatusCallback_iface);
1149     return hres;
1150 }
1151
1152 static void parse_inline_script(ScriptHost *script_host, HTMLScriptElement *script_elem)
1153 {
1154     const PRUnichar *text;
1155     nsAString text_str;
1156     nsresult nsres;
1157
1158     nsAString_Init(&text_str, NULL);
1159     nsres = nsIDOMHTMLScriptElement_GetText(script_elem->nsscript, &text_str);
1160     nsAString_GetData(&text_str, &text);
1161
1162     set_script_elem_readystate(script_elem, READYSTATE_INTERACTIVE);
1163
1164     if(NS_FAILED(nsres)) {
1165         ERR("GetText failed: %08lx\n", nsres);
1166     }else if(*text) {
1167         parse_elem_text(script_host, script_elem, text);
1168     }
1169
1170     nsAString_Finish(&text_str);
1171 }
1172
1173 static BOOL parse_script_elem(ScriptHost *script_host, HTMLScriptElement *script_elem)
1174 {
1175     nsAString src_str, event_str;
1176     BOOL is_complete = FALSE;
1177     const PRUnichar *src;
1178     nsresult nsres;
1179
1180     nsAString_Init(&event_str, NULL);
1181     nsres = nsIDOMHTMLScriptElement_GetEvent(script_elem->nsscript, &event_str);
1182     if(NS_SUCCEEDED(nsres)) {
1183         const PRUnichar *event;
1184
1185         nsAString_GetData(&event_str, &event);
1186         if(*event) {
1187             TRACE("deferring event %s script evaluation\n", debugstr_w(event));
1188             nsAString_Finish(&event_str);
1189             return FALSE;
1190         }
1191     }else {
1192         ERR("GetEvent failed: %08lx\n", nsres);
1193     }
1194     nsAString_Finish(&event_str);
1195
1196     nsAString_Init(&src_str, NULL);
1197     nsres = nsIDOMHTMLScriptElement_GetSrc(script_elem->nsscript, &src_str);
1198     nsAString_GetData(&src_str, &src);
1199
1200     if(NS_FAILED(nsres)) {
1201         ERR("GetSrc failed: %08lx\n", nsres);
1202     }else if(*src) {
1203         load_script(script_elem, src, FALSE);
1204         is_complete = script_elem->parsed;
1205     }else {
1206         parse_inline_script(script_host, script_elem);
1207         is_complete = TRUE;
1208     }
1209
1210     nsAString_Finish(&src_str);
1211
1212     return is_complete;
1213 }
1214
1215 static GUID get_default_script_guid(HTMLInnerWindow *window)
1216 {
1217     /* If not specified, we should use very first script host that was created for the page (or JScript if none) */
1218     return list_empty(&window->script_hosts)
1219         ? CLSID_JScript
1220         : LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry)->guid;
1221 }
1222
1223 static BOOL get_guid_from_type(LPCWSTR type, GUID *guid)
1224 {
1225     /* FIXME: Handle more types */
1226     if(!wcsicmp(type, L"text/javascript") || !wcsicmp(type, L"text/jscript")) {
1227         *guid = CLSID_JScript;
1228     }else if(!wcsicmp(type, L"text/vbscript")) {
1229         *guid = CLSID_VBScript;
1230     }else {
1231         FIXME("Unknown type %s\n", debugstr_w(type));
1232         return FALSE;
1233     }
1234
1235     return TRUE;
1236 }
1237
1238 static BOOL get_guid_from_language(LPCWSTR type, GUID *guid)
1239 {
1240     HRESULT hres;
1241
1242     hres = CLSIDFromProgID(type, guid);
1243     if(FAILED(hres))
1244         return FALSE;
1245
1246     /* FIXME: Check CATID_ActiveScriptParse */
1247
1248     return TRUE;
1249 }
1250
1251 static BOOL get_script_guid(HTMLInnerWindow *window, nsIDOMHTMLScriptElement *nsscript, GUID *guid)
1252 {
1253     nsIDOMElement *nselem;
1254     const PRUnichar *language;
1255     nsAString val_str;
1256     BOOL ret = FALSE;
1257     nsresult nsres;
1258
1259     nsAString_Init(&val_str, NULL);
1260
1261     nsres = nsIDOMHTMLScriptElement_GetType(nsscript, &val_str);
1262     if(NS_SUCCEEDED(nsres)) {
1263         const PRUnichar *type;
1264
1265         nsAString_GetData(&val_str, &type);
1266         if(*type) {
1267             ret = get_guid_from_type(type, guid);
1268             nsAString_Finish(&val_str);
1269             return ret;
1270         }
1271     }else {
1272         ERR("GetType failed: %08lx\n", nsres);
1273     }
1274
1275     nsres = nsIDOMHTMLScriptElement_QueryInterface(nsscript, &IID_nsIDOMElement, (void**)&nselem);
1276     assert(nsres == NS_OK);
1277
1278     nsres = get_elem_attr_value(nselem, L"language", &val_str, &language);
1279     nsIDOMElement_Release(nselem);
1280     if(NS_SUCCEEDED(nsres)) {
1281         if(*language) {
1282             ret = get_guid_from_language(language, guid);
1283         }else {
1284             *guid = get_default_script_guid(window);
1285             ret = TRUE;
1286         }
1287         nsAString_Finish(&val_str);
1288     }
1289
1290     return ret;
1291 }
1292
1293 static ScriptHost *get_script_host(HTMLInnerWindow *window, const GUID *guid)
1294 {
1295     ScriptHost *iter;
1296
1297     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
1298         if(IsEqualGUID(guid, &iter->guid))
1299             return iter;
1300     }
1301
1302     return create_script_host(window, guid);
1303 }
1304
1305 static ScriptHost *get_elem_script_host(HTMLInnerWindow *window, HTMLScriptElement *script_elem)
1306 {
1307     GUID guid;
1308
1309     if(!get_script_guid(window, script_elem->nsscript, &guid)) {
1310         WARN("Could not find script GUID\n");
1311         return NULL;
1312     }
1313
1314     if(IsEqualGUID(&CLSID_JScript, &guid) && (!window->doc->browser || window->doc->browser->script_mode != SCRIPTMODE_ACTIVESCRIPT)) {
1315         TRACE("Ignoring JScript\n");
1316         return NULL;
1317     }
1318
1319     return get_script_host(window, &guid);
1320 }
1321
1322 void doc_insert_script(HTMLInnerWindow *window, HTMLScriptElement *script_elem, BOOL from_parser)
1323 {
1324     ScriptHost *script_host;
1325     BOOL is_complete = FALSE;
1326
1327     script_host = get_elem_script_host(window, script_elem);
1328     if(!script_host)
1329         return;
1330
1331     if(script_host->parse) {
1332         if(script_elem->src_text) {
1333             if(from_parser)
1334                 set_script_elem_readystate(script_elem, READYSTATE_INTERACTIVE);
1335             script_elem->parsed = TRUE;
1336             parse_elem_text(script_host, script_elem, script_elem->src_text);
1337             is_complete = TRUE;
1338         }else if(!script_elem->binding) {
1339             is_complete = parse_script_elem(script_host, script_elem);
1340         }
1341     }
1342
1343     if(is_complete)
1344         set_script_elem_readystate(script_elem, READYSTATE_COMPLETE);
1345 }
1346
1347 IDispatch *script_parse_event(HTMLInnerWindow *window, LPCWSTR text)
1348 {
1349     ScriptHost *script_host;
1350     GUID guid;
1351     const WCHAR *ptr;
1352     IDispatch *disp;
1353     HRESULT hres;
1354
1355     TRACE("%s\n", debugstr_w(text));
1356
1357     for(ptr = text; iswalnum(*ptr); ptr++);
1358     if(*ptr == ':') {
1359         LPWSTR language;
1360         BOOL b;
1361
1362         language = heap_alloc((ptr-text+1)*sizeof(WCHAR));
1363         if(!language)
1364             return NULL;
1365
1366         memcpy(language, text, (ptr-text)*sizeof(WCHAR));
1367         language[ptr-text] = 0;
1368
1369         b = get_guid_from_language(language, &guid);
1370
1371         heap_free(language);
1372
1373         if(!b) {
1374             WARN("Could not find language\n");
1375             return NULL;
1376         }
1377
1378         ptr++;
1379     }else {
1380         ptr = text;
1381         guid = get_default_script_guid(window);
1382     }
1383
1384     if(IsEqualGUID(&CLSID_JScript, &guid)
1385        && (!window->doc->browser || window->doc->browser->script_mode != SCRIPTMODE_ACTIVESCRIPT)) {
1386         TRACE("Ignoring JScript\n");
1387         return NULL;
1388     }
1389
1390     script_host = get_script_host(window, &guid);
1391     if(!script_host || !script_host->parse_proc)
1392         return NULL;
1393
1394     hres = IActiveScriptParseProcedure2_ParseProcedureText(script_host->parse_proc, ptr, NULL, L"",
1395             NULL, NULL, L"\"", 0 /* FIXME */, 0,
1396             SCRIPTPROC_HOSTMANAGESSOURCE|SCRIPTPROC_IMPLICIT_THIS|SCRIPTPROC_IMPLICIT_PARENTS, &disp);
1397     if(FAILED(hres)) {
1398         WARN("ParseProcedureText failed: %08lx\n", hres);
1399         return NULL;
1400     }
1401
1402     TRACE("ret %p\n", disp);
1403     return disp;
1404 }
1405
1406 HRESULT exec_script(HTMLInnerWindow *window, const WCHAR *code, const WCHAR *lang, VARIANT *ret)
1407 {
1408     ScriptHost *script_host;
1409     EXCEPINFO ei;
1410     GUID guid;
1411     HRESULT hres;
1412
1413     if(!get_guid_from_language(lang, &guid)) {
1414         WARN("Could not find script GUID\n");
1415         return CO_E_CLASSSTRING;
1416     }
1417
1418     script_host = get_script_host(window, &guid);
1419     if(!script_host) {
1420         FIXME("No script host\n");
1421         return E_FAIL;
1422     }
1423
1424     if(!script_host->parse) {
1425         FIXME("script_host->parse == NULL\n");
1426         return E_FAIL;
1427     }
1428
1429     memset(&ei, 0, sizeof(ei));
1430     TRACE(">>>\n");
1431     hres = IActiveScriptParse_ParseScriptText(script_host->parse, code, NULL, NULL, L"\"", 0, 0, SCRIPTTEXT_ISVISIBLE, ret, &ei);
1432     if(SUCCEEDED(hres))
1433         TRACE("<<<\n");
1434     else
1435         WARN("<<< %08lx\n", hres);
1436
1437     return hres;
1438 }
1439
1440 IDispatch *get_script_disp(ScriptHost *script_host)
1441 {
1442     IDispatch *disp;
1443     HRESULT hres;
1444
1445     if(!script_host->script)
1446         return NULL;
1447
1448     hres = IActiveScript_GetScriptDispatch(script_host->script, L"window", &disp);
1449     if(FAILED(hres))
1450         return NULL;
1451
1452     return disp;
1453 }
1454
1455 static EventTarget *find_event_target(HTMLDocumentNode *doc, HTMLScriptElement *script_elem)
1456 {
1457     EventTarget *event_target = NULL;
1458     const PRUnichar *target_id;
1459     nsAString target_id_str;
1460     nsresult nsres;
1461     HRESULT hres;
1462
1463     nsAString_Init(&target_id_str, NULL);
1464     nsres = nsIDOMHTMLScriptElement_GetHtmlFor(script_elem->nsscript, &target_id_str);
1465     if(NS_FAILED(nsres)) {
1466         ERR("GetScriptFor failed: %08lx\n", nsres);
1467         nsAString_Finish(&target_id_str);
1468         return NULL;
1469     }
1470
1471     nsAString_GetData(&target_id_str, &target_id);
1472     if(!*target_id) {
1473         FIXME("Empty for attribute\n");
1474     }else if(!wcscmp(target_id, L"document")) {
1475         event_target = &doc->node.event_target;
1476         htmldoc_addref(&doc->basedoc);
1477     }else if(!wcscmp(target_id, L"window")) {
1478         if(doc->window) {
1479             event_target = &doc->window->event_target;
1480             IDispatchEx_AddRef(&event_target->dispex.IDispatchEx_iface);
1481         }
1482     }else {
1483         HTMLElement *target_elem;
1484
1485         hres = get_doc_elem_by_id(doc, target_id, &target_elem);
1486         if(SUCCEEDED(hres) && target_elem) {
1487             event_target = &target_elem->node.event_target;
1488         }
1489     }
1490
1491     nsAString_Finish(&target_id_str);
1492     return event_target;
1493 }
1494
1495 static BOOL parse_event_str(WCHAR *event, const WCHAR **args)
1496 {
1497     WCHAR *ptr;
1498
1499     TRACE("%s\n", debugstr_w(event));
1500
1501     for(ptr = event; iswalnum(*ptr); ptr++);
1502     if(!*ptr) {
1503         *args = NULL;
1504         return TRUE;
1505     }
1506
1507     if(*ptr != '(')
1508         return FALSE;
1509
1510     *ptr++ = 0;
1511     *args = ptr;
1512     while(iswalnum(*ptr) || iswspace(*ptr) || *ptr == ',')
1513         ptr++;
1514
1515     if(*ptr != ')')
1516         return FALSE;
1517
1518     *ptr++ = 0;
1519     return !*ptr;
1520 }
1521
1522 static IDispatch *parse_event_elem(HTMLDocumentNode *doc, HTMLScriptElement *script_elem, WCHAR **ret_event)
1523 {
1524     ScriptHost *script_host;
1525     WCHAR *event = NULL;
1526     const WCHAR *args;
1527     nsAString nsstr;
1528     IDispatch *disp;
1529     nsresult nsres;
1530     HRESULT hres;
1531
1532     if(script_elem->parsed)
1533         return NULL;
1534
1535     script_host = get_elem_script_host(doc->window, script_elem);
1536     if(!script_host || !script_host->parse_proc)
1537         return NULL;
1538
1539     nsAString_Init(&nsstr, NULL);
1540     nsres = nsIDOMHTMLScriptElement_GetEvent(script_elem->nsscript, &nsstr);
1541     if(NS_SUCCEEDED(nsres)) {
1542         const PRUnichar *event_val;
1543
1544         nsAString_GetData(&nsstr, &event_val);
1545         event = heap_strdupW(event_val);
1546     }
1547     nsAString_Finish(&nsstr);
1548     if(!event)
1549         return NULL;
1550
1551     if(!parse_event_str(event, &args)) {
1552         WARN("parsing %s failed\n", debugstr_w(event));
1553         heap_free(event);
1554         return NULL;
1555     }
1556
1557     nsAString_Init(&nsstr, NULL);
1558     nsres = nsIDOMHTMLScriptElement_GetText(script_elem->nsscript, &nsstr);
1559     if(NS_SUCCEEDED(nsres)) {
1560         const PRUnichar *text;
1561
1562         nsAString_GetData(&nsstr, &text);
1563         hres = IActiveScriptParseProcedure2_ParseProcedureText(script_host->parse_proc, text, args,
1564                 L"", NULL, NULL, L"</SCRIPT>", 0, 0,
1565                 SCRIPTPROC_HOSTMANAGESSOURCE|SCRIPTPROC_IMPLICIT_THIS|SCRIPTPROC_IMPLICIT_PARENTS, &disp);
1566         if(FAILED(hres))
1567             disp = NULL;
1568     }else {
1569         ERR("GetText failed: %08lx\n", nsres);
1570         disp = NULL;
1571     }
1572     nsAString_Finish(&nsstr);
1573     if(!disp) {
1574         heap_free(event);
1575         return NULL;
1576     }
1577
1578     *ret_event = event;
1579     return disp;
1580 }
1581
1582 void bind_event_scripts(HTMLDocumentNode *doc)
1583 {
1584     HTMLPluginContainer *plugin_container;
1585     nsIDOMHTMLScriptElement *nsscript;
1586     HTMLScriptElement *script_elem;
1587     EventTarget *event_target;
1588     nsIDOMNodeList *node_list;
1589     nsIDOMNode *script_node;
1590     nsAString selector_str;
1591     IDispatch *event_disp;
1592     UINT32 length, i;
1593     WCHAR *event;
1594     nsresult nsres;
1595     HRESULT hres;
1596
1597     TRACE("%p\n", doc);
1598
1599     if(!doc->nsdoc)
1600         return;
1601
1602     nsAString_InitDepend(&selector_str, L"script[event]");
1603     nsres = nsIDOMHTMLDocument_QuerySelectorAll(doc->nsdoc, &selector_str, &node_list);
1604     nsAString_Finish(&selector_str);
1605     if(NS_FAILED(nsres)) {
1606         ERR("QuerySelectorAll failed: %08lx\n", nsres);
1607         return;
1608     }
1609
1610     if(!node_list)
1611         return;
1612
1613     nsres = nsIDOMNodeList_GetLength(node_list, &length);
1614     assert(nsres == NS_OK);
1615
1616     for(i=0; i < length; i++) {
1617         nsres = nsIDOMNodeList_Item(node_list, i, &script_node);
1618         if(NS_FAILED(nsres) || !script_node) {
1619             ERR("Item(%d) failed: %08lx\n", i, nsres);
1620             continue;
1621         }
1622
1623         nsres = nsIDOMNode_QueryInterface(script_node, &IID_nsIDOMHTMLScriptElement, (void**)&nsscript);
1624         assert(nsres == NS_OK);
1625         nsIDOMNode_Release(script_node);
1626
1627         hres = script_elem_from_nsscript(nsscript, &script_elem);
1628         if(FAILED(hres))
1629             continue;
1630
1631         event_disp = parse_event_elem(doc, script_elem, &event);
1632         if(event_disp) {
1633             event_target = find_event_target(doc, script_elem);
1634             if(event_target) {
1635                 hres = IDispatchEx_QueryInterface(&event_target->dispex.IDispatchEx_iface, &IID_HTMLPluginContainer,
1636                         (void**)&plugin_container);
1637                 if(SUCCEEDED(hres))
1638                     bind_activex_event(doc, plugin_container, event, event_disp);
1639                 else
1640                     bind_target_event(doc, event_target, event, event_disp);
1641
1642                 IDispatchEx_Release(&event_target->dispex.IDispatchEx_iface);
1643                 if(plugin_container)
1644                     node_release(&plugin_container->element.node);
1645             }
1646
1647             heap_free(event);
1648             IDispatch_Release(event_disp);
1649         }
1650
1651         IHTMLScriptElement_Release(&script_elem->IHTMLScriptElement_iface);
1652     }
1653
1654     nsIDOMNodeList_Release(node_list);
1655 }
1656
1657 BOOL find_global_prop(HTMLInnerWindow *window, BSTR name, DWORD flags, ScriptHost **ret_host, DISPID *ret_id)
1658 {
1659     IDispatchEx *dispex;
1660     IDispatch *disp;
1661     ScriptHost *iter;
1662     HRESULT hres;
1663
1664     LIST_FOR_EACH_ENTRY(iter, &window->script_hosts, ScriptHost, entry) {
1665         disp = get_script_disp(iter);
1666         if(!disp)
1667             continue;
1668
1669         hres = IDispatch_QueryInterface(disp, &IID_IDispatchEx, (void**)&dispex);
1670         if(SUCCEEDED(hres)) {
1671             hres = IDispatchEx_GetDispID(dispex, name, flags & (~fdexNameEnsure), ret_id);
1672             IDispatchEx_Release(dispex);
1673         }else {
1674             FIXME("No IDispatchEx\n");
1675             hres = E_NOTIMPL;
1676         }
1677
1678         IDispatch_Release(disp);
1679         if(SUCCEEDED(hres)) {
1680             *ret_host = iter;
1681             return TRUE;
1682         }
1683     }
1684
1685     return FALSE;
1686 }
1687
1688 static BOOL is_jscript_available(void)
1689 {
1690     static BOOL available, checked;
1691
1692     if(!checked) {
1693         IUnknown *unk;
1694         HRESULT hres = CoGetClassObject(&CLSID_JScript, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
1695
1696         if(SUCCEEDED(hres)) {
1697             available = TRUE;
1698             IUnknown_Release(unk);
1699         }else {
1700             available = FALSE;
1701         }
1702         checked = TRUE;
1703     }
1704
1705     return available;
1706 }
1707
1708 static BOOL use_gecko_script(IUri *uri)
1709 {
1710     BSTR display_uri;
1711     DWORD zone;
1712     HRESULT hres;
1713
1714     hres = IUri_GetDisplayUri(uri, &display_uri);
1715     if(FAILED(hres))
1716         return FALSE;
1717
1718     hres = IInternetSecurityManager_MapUrlToZone(get_security_manager(), display_uri, &zone, 0);
1719     if(FAILED(hres)) {
1720         WARN("Could not map %s to zone: %08lx\n", debugstr_w(display_uri), hres);
1721         SysFreeString(display_uri);
1722         return TRUE;
1723     }
1724
1725     SysFreeString(display_uri);
1726     TRACE("zone %ld\n", zone);
1727     return zone == URLZONE_UNTRUSTED;
1728 }
1729
1730 void update_browser_script_mode(GeckoBrowser *browser, IUri *uri)
1731 {
1732     nsIWebBrowserSetup *setup;
1733     nsresult nsres;
1734
1735     if(!is_jscript_available()) {
1736         TRACE("jscript.dll not available\n");
1737         browser->script_mode = SCRIPTMODE_GECKO;
1738         return;
1739     }
1740
1741     browser->script_mode = use_gecko_script(uri) ? SCRIPTMODE_GECKO : SCRIPTMODE_ACTIVESCRIPT;
1742
1743     nsres = nsIWebBrowser_QueryInterface(browser->webbrowser, &IID_nsIWebBrowserSetup, (void**)&setup);
1744     if(NS_SUCCEEDED(nsres)) {
1745         nsres = nsIWebBrowserSetup_SetProperty(setup, SETUP_ALLOW_JAVASCRIPT,
1746                 browser->script_mode == SCRIPTMODE_GECKO);
1747
1748         if(NS_SUCCEEDED(nsres))
1749             nsres = nsIWebBrowserSetup_SetProperty(setup, SETUP_DISABLE_NOSCRIPT, TRUE);
1750
1751         nsIWebBrowserSetup_Release(setup);
1752     }
1753
1754     if(NS_FAILED(nsres))
1755         ERR("JavaScript setup failed: %08lx\n", nsres);
1756 }
1757
1758 void release_script_hosts(HTMLInnerWindow *window)
1759 {
1760     script_queue_entry_t *queue_iter;
1761     ScriptHost *iter;
1762
1763     while(!list_empty(&window->script_queue)) {
1764         queue_iter = LIST_ENTRY(list_head(&window->script_queue), script_queue_entry_t, entry);
1765
1766         list_remove(&queue_iter->entry);
1767         IHTMLScriptElement_Release(&queue_iter->script->IHTMLScriptElement_iface);
1768         heap_free(queue_iter);
1769     }
1770
1771     while(!list_empty(&window->script_hosts)) {
1772         iter = LIST_ENTRY(list_head(&window->script_hosts), ScriptHost, entry);
1773
1774         release_script_engine(iter);
1775         list_remove(&iter->entry);
1776         iter->window = NULL;
1777         IActiveScriptSite_Release(&iter->IActiveScriptSite_iface);
1778     }
1779 }