dlls/mshtml/xmlhttprequest.c

   1 /*
   2  * Copyright 2015 Zhenbo Li
   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 #include <assert.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "ole2.h"
  28
  29 #include "wine/debug.h"
  30
  31 #include "mshtml_private.h"
  32 #include "htmlevent.h"
  33 #include "mshtmdid.h"
  34 #include "initguid.h"
  35 #include "msxml6.h"
  36 #include "objsafe.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  39
  40 #define MSHTML_DISPID_HTMLXMLHTTPREQUEST_ONLOAD MSHTML_DISPID_CUSTOM_MIN
  41
  42 static HRESULT bstr_to_nsacstr(BSTR bstr, nsACString *str)
  43 {
  44     char *cstr = heap_strdupWtoU(bstr);
  45     if(!cstr)
  46         return E_OUTOFMEMORY;
  47     nsACString_Init(str, cstr);
  48     heap_free(cstr);
  49     return S_OK;
  50 }
  51
  52 static HRESULT variant_to_nsastr(VARIANT var, nsAString *ret)
  53 {
  54     switch(V_VT(&var)) {
  55         case VT_NULL:
  56         case VT_ERROR:
  57         case VT_EMPTY:
  58             nsAString_Init(ret, NULL);
  59             return S_OK;
  60         case VT_BSTR:
  61             nsAString_InitDepend(ret, V_BSTR(&var));
  62             return S_OK;
  63         default:
  64             FIXME("Unsupported VARIANT: %s\n", debugstr_variant(&var));
  65             return E_INVALIDARG;
  66     }
  67 }
  68
  69 static HRESULT return_nscstr(nsresult nsres, nsACString *nscstr, BSTR *p)
  70 {
  71     const char *str;
  72     int len;
  73
  74     if(NS_FAILED(nsres)) {
  75         ERR("failed: %08x\n", nsres);
  76         nsACString_Finish(nscstr);
  77         return E_FAIL;
  78     }
  79
  80     nsACString_GetData(nscstr, &str);
  81
  82     if(*str) {
  83         len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
  84         *p = SysAllocStringLen(NULL, len - 1);
  85         if(!*p) {
  86             nsACString_Finish(nscstr);
  87             return E_OUTOFMEMORY;
  88         }
  89         MultiByteToWideChar(CP_UTF8, 0, str, -1, *p, len);
  90     }else {
  91         *p = NULL;
  92     }
  93
  94     nsACString_Finish(nscstr);
  95     return S_OK;
  96 }
  97
  98 typedef struct {
  99     nsIDOMEventListener nsIDOMEventListener_iface;
 100     LONG ref;
 101     HTMLXMLHttpRequest *xhr;
 102     BOOL readystatechange_event;
 103     BOOL load_event;
 104 } XMLHttpReqEventListener;
 105
 106 struct HTMLXMLHttpRequest {
 107     EventTarget event_target;
 108     IHTMLXMLHttpRequest IHTMLXMLHttpRequest_iface;
 109     IProvideClassInfo2 IProvideClassInfo2_iface;
 110     LONG ref;
 111     nsIXMLHttpRequest *nsxhr;
 112     XMLHttpReqEventListener *event_listener;
 113 };
 114
 115 static void detach_xhr_event_listener(XMLHttpReqEventListener *event_listener)
 116 {
 117     nsIDOMEventTarget *event_target;
 118     nsAString str;
 119     nsresult nsres;
 120
 121     nsres = nsIXMLHttpRequest_QueryInterface(event_listener->xhr->nsxhr, &IID_nsIDOMEventTarget, (void**)&event_target);
 122     assert(nsres == NS_OK);
 123
 124     if(event_listener->readystatechange_event) {
 125         nsAString_InitDepend(&str, L"onreadystatechange");
 126         nsres = nsIDOMEventTarget_RemoveEventListener(event_target, &str, &event_listener->nsIDOMEventListener_iface, FALSE);
 127         nsAString_Finish(&str);
 128         assert(nsres == NS_OK);
 129     }
 130
 131     if(event_listener->load_event) {
 132         nsAString_InitDepend(&str, L"load");
 133         nsres = nsIDOMEventTarget_RemoveEventListener(event_target, &str, &event_listener->nsIDOMEventListener_iface, FALSE);
 134         nsAString_Finish(&str);
 135         assert(nsres == NS_OK);
 136     }
 137
 138     nsIDOMEventTarget_Release(event_target);
 139
 140     event_listener->xhr->event_listener = NULL;
 141     event_listener->xhr = NULL;
 142     nsIDOMEventListener_Release(&event_listener->nsIDOMEventListener_iface);
 143 }
 144
 145
 146 static inline XMLHttpReqEventListener *impl_from_nsIDOMEventListener(nsIDOMEventListener *iface)
 147 {
 148     return CONTAINING_RECORD(iface, XMLHttpReqEventListener, nsIDOMEventListener_iface);
 149 }
 150
 151 static nsresult NSAPI XMLHttpReqEventListener_QueryInterface(nsIDOMEventListener *iface,
 152         nsIIDRef riid, void **result)
 153 {
 154     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 155
 156     if(IsEqualGUID(&IID_nsISupports, riid)) {
 157         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
 158         *result = &This->nsIDOMEventListener_iface;
 159     }else if(IsEqualGUID(&IID_nsIDOMEventListener, riid)) {
 160         TRACE("(%p)->(IID_nsIDOMEventListener %p)\n", This, result);
 161         *result = &This->nsIDOMEventListener_iface;
 162     }else {
 163         *result = NULL;
 164         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 165         return NS_NOINTERFACE;
 166     }
 167
 168     nsIDOMEventListener_AddRef(&This->nsIDOMEventListener_iface);
 169     return NS_OK;
 170 }
 171
 172 static nsrefcnt NSAPI XMLHttpReqEventListener_AddRef(nsIDOMEventListener *iface)
 173 {
 174     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 175     LONG ref = InterlockedIncrement(&This->ref);
 176
 177     TRACE("(%p) ref=%d\n", This, ref);
 178
 179     return ref;
 180 }
 181
 182 static nsrefcnt NSAPI XMLHttpReqEventListener_Release(nsIDOMEventListener *iface)
 183 {
 184     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 185     LONG ref = InterlockedDecrement(&This->ref);
 186
 187     TRACE("(%p) ref=%d\n", This, ref);
 188
 189     if(!ref) {
 190         assert(!This->xhr);
 191         heap_free(This);
 192     }
 193
 194     return ref;
 195 }
 196
 197 static nsresult NSAPI XMLHttpReqEventListener_HandleEvent(nsIDOMEventListener *iface, nsIDOMEvent *nsevent)
 198 {
 199     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 200     DOMEvent *event;
 201     HRESULT hres;
 202
 203     TRACE("(%p)\n", This);
 204
 205     if(!This->xhr)
 206         return NS_OK;
 207
 208     hres = create_event_from_nsevent(nsevent, dispex_compat_mode(&This->xhr->event_target.dispex), &event);
 209     if(SUCCEEDED(hres) ){
 210         dispatch_event(&This->xhr->event_target, event);
 211         IDOMEvent_Release(&event->IDOMEvent_iface);
 212     }
 213     return NS_OK;
 214 }
 215
 216 static const nsIDOMEventListenerVtbl XMLHttpReqEventListenerVtbl = {
 217     XMLHttpReqEventListener_QueryInterface,
 218     XMLHttpReqEventListener_AddRef,
 219     XMLHttpReqEventListener_Release,
 220     XMLHttpReqEventListener_HandleEvent
 221 };
 222
 223 static inline HTMLXMLHttpRequest *impl_from_IHTMLXMLHttpRequest(IHTMLXMLHttpRequest *iface)
 224 {
 225     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IHTMLXMLHttpRequest_iface);
 226 }
 227
 228 static HRESULT WINAPI HTMLXMLHttpRequest_QueryInterface(IHTMLXMLHttpRequest *iface, REFIID riid, void **ppv)
 229 {
 230     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 231
 232     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 233
 234     if(IsEqualGUID(&IID_IUnknown, riid)) {
 235         *ppv = &This->IHTMLXMLHttpRequest_iface;
 236     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 237         *ppv = &This->IHTMLXMLHttpRequest_iface;
 238     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequest, riid)) {
 239         *ppv = &This->IHTMLXMLHttpRequest_iface;
 240     }else if(IsEqualGUID(&IID_IProvideClassInfo, riid)) {
 241         *ppv = &This->IProvideClassInfo2_iface;
 242     }else if(IsEqualGUID(&IID_IProvideClassInfo2, riid)) {
 243         *ppv = &This->IProvideClassInfo2_iface;
 244     }else {
 245         return EventTarget_QI(&This->event_target, riid, ppv);
 246     }
 247
 248     IUnknown_AddRef((IUnknown*)*ppv);
 249     return S_OK;
 250 }
 251
 252 static ULONG WINAPI HTMLXMLHttpRequest_AddRef(IHTMLXMLHttpRequest *iface)
 253 {
 254     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 255     LONG ref = InterlockedIncrement(&This->ref);
 256
 257     TRACE("(%p) ref=%d\n", This, ref);
 258
 259     return ref;
 260 }
 261
 262 static ULONG WINAPI HTMLXMLHttpRequest_Release(IHTMLXMLHttpRequest *iface)
 263 {
 264     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 265     LONG ref = InterlockedDecrement(&This->ref);
 266
 267     TRACE("(%p) ref=%d\n", This, ref);
 268
 269     if(!ref) {
 270         if(This->event_listener)
 271             detach_xhr_event_listener(This->event_listener);
 272         release_event_target(&This->event_target);
 273         release_dispex(&This->event_target.dispex);
 274         nsIXMLHttpRequest_Release(This->nsxhr);
 275         heap_free(This);
 276     }
 277
 278     return ref;
 279 }
 280
 281 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfoCount(IHTMLXMLHttpRequest *iface, UINT *pctinfo)
 282 {
 283     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 284     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
 285 }
 286
 287 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfo(IHTMLXMLHttpRequest *iface, UINT iTInfo,
 288         LCID lcid, ITypeInfo **ppTInfo)
 289 {
 290     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 291
 292     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 293 }
 294
 295 static HRESULT WINAPI HTMLXMLHttpRequest_GetIDsOfNames(IHTMLXMLHttpRequest *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 296         LCID lcid, DISPID *rgDispId)
 297 {
 298     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 299
 300     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 301             lcid, rgDispId);
 302 }
 303
 304 static HRESULT WINAPI HTMLXMLHttpRequest_Invoke(IHTMLXMLHttpRequest *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 305         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 306 {
 307     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 308
 309     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 310             pDispParams, pVarResult, pExcepInfo, puArgErr);
 311 }
 312
 313 static HRESULT WINAPI HTMLXMLHttpRequest_get_readyState(IHTMLXMLHttpRequest *iface, LONG *p)
 314 {
 315     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 316     UINT16 val;
 317     nsresult nsres;
 318
 319     TRACE("(%p)->(%p)\n", This, p);
 320
 321     if(!p)
 322         return E_POINTER;
 323     nsres = nsIXMLHttpRequest_GetReadyState(This->nsxhr, &val);
 324     if(NS_FAILED(nsres)) {
 325         ERR("nsIXMLHttpRequest_GetReadyState failed: %08x\n", nsres);
 326         return E_FAIL;
 327     }
 328     *p = val;
 329     return S_OK;
 330 }
 331
 332 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseBody(IHTMLXMLHttpRequest *iface, VARIANT *p)
 333 {
 334     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 335     FIXME("(%p)->(%p)\n", This, p);
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseText(IHTMLXMLHttpRequest *iface, BSTR *p)
 340 {
 341     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 342     nsAString nsstr;
 343     nsresult nsres;
 344
 345     TRACE("(%p)->(%p)\n", This, p);
 346
 347     if(!p)
 348         return E_POINTER;
 349
 350     nsAString_Init(&nsstr, NULL);
 351     nsres = nsIXMLHttpRequest_GetResponseText(This->nsxhr, &nsstr);
 352     return return_nsstr(nsres, &nsstr, p);
 353 }
 354
 355 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseXML(IHTMLXMLHttpRequest *iface, IDispatch **p)
 356 {
 357     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 358     IXMLDOMDocument *xmldoc = NULL;
 359     BSTR str;
 360     HRESULT hres;
 361     VARIANT_BOOL vbool;
 362     IObjectSafety *safety;
 363
 364     TRACE("(%p)->(%p)\n", This, p);
 365
 366     hres = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&xmldoc);
 367     if(FAILED(hres)) {
 368         ERR("CoCreateInstance failed: %08x\n", hres);
 369         return hres;
 370     }
 371
 372     hres = IHTMLXMLHttpRequest_get_responseText(iface, &str);
 373     if(FAILED(hres)) {
 374         IXMLDOMDocument_Release(xmldoc);
 375         ERR("get_responseText failed: %08x\n", hres);
 376         return hres;
 377     }
 378
 379     hres = IXMLDOMDocument_loadXML(xmldoc, str, &vbool);
 380     SysFreeString(str);
 381     if(hres != S_OK || vbool != VARIANT_TRUE)
 382         WARN("loadXML failed: %08x, returning an empty xmldoc\n", hres);
 383
 384     hres = IXMLDOMDocument_QueryInterface(xmldoc, &IID_IObjectSafety, (void**)&safety);
 385     assert(SUCCEEDED(hres));
 386     hres = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
 387         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER,
 388         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER);
 389     assert(SUCCEEDED(hres));
 390     IObjectSafety_Release(safety);
 391
 392     *p = (IDispatch*)xmldoc;
 393     return S_OK;
 394 }
 395
 396 static HRESULT WINAPI HTMLXMLHttpRequest_get_status(IHTMLXMLHttpRequest *iface, LONG *p)
 397 {
 398     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 399     DWORD val;
 400     nsresult nsres;
 401     TRACE("(%p)->(%p)\n", This, p);
 402
 403     if(!p)
 404         return E_POINTER;
 405
 406     nsres = nsIXMLHttpRequest_GetStatus(This->nsxhr, &val);
 407     if(NS_FAILED(nsres)) {
 408         ERR("nsIXMLHttpRequest_GetStatus failed: %08x\n", nsres);
 409         return E_FAIL;
 410     }
 411     *p = val;
 412     if(val == 0)
 413         return E_FAIL; /* WinAPI thinks this is an error */
 414
 415     return S_OK;
 416 }
 417
 418 static HRESULT WINAPI HTMLXMLHttpRequest_get_statusText(IHTMLXMLHttpRequest *iface, BSTR *p)
 419 {
 420     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 421     nsACString nscstr;
 422     nsresult nsres;
 423     HRESULT hres;
 424     LONG state;
 425
 426     TRACE("(%p)->(%p)\n", This, p);
 427
 428     if(!p)
 429         return E_POINTER;
 430
 431     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 432     if(FAILED(hres))
 433         return hres;
 434
 435     if(state < 2) {
 436         *p = NULL;
 437         return E_FAIL;
 438     }
 439
 440     nsACString_Init(&nscstr, NULL);
 441     nsres = nsIXMLHttpRequest_GetStatusText(This->nsxhr, &nscstr);
 442     return return_nscstr(nsres, &nscstr, p);
 443 }
 444
 445 static HRESULT WINAPI HTMLXMLHttpRequest_put_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT v)
 446 {
 447     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 448
 449     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 450
 451     return set_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, &v);
 452 }
 453
 454 static HRESULT WINAPI HTMLXMLHttpRequest_get_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT *p)
 455 {
 456     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 457
 458     TRACE("(%p)->(%p)\n", This, p);
 459
 460     return get_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, p);
 461 }
 462
 463 static HRESULT WINAPI HTMLXMLHttpRequest_abort(IHTMLXMLHttpRequest *iface)
 464 {
 465     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 466     nsresult nsres;
 467
 468     TRACE("(%p)->()\n", This);
 469
 470     nsres = nsIXMLHttpRequest_SlowAbort(This->nsxhr);
 471     if(NS_FAILED(nsres)) {
 472         ERR("nsIXMLHttpRequest_SlowAbort failed: %08x\n", nsres);
 473         return E_FAIL;
 474     }
 475
 476     return S_OK;
 477 }
 478
 479 static HRESULT HTMLXMLHttpRequest_open_hook(DispatchEx *dispex, LCID lcid, WORD flags,
 480         DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 481 {
 482     /* If only two arguments were given, implicitly set async to false */
 483     if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
 484         VARIANT args[5];
 485         DISPPARAMS new_dp = {args, NULL, ARRAY_SIZE(args), 0};
 486         V_VT(args) = VT_EMPTY;
 487         V_VT(args+1) = VT_EMPTY;
 488         V_VT(args+2) = VT_BOOL;
 489         V_BOOL(args+2) = VARIANT_TRUE;
 490         args[3] = dp->rgvarg[0];
 491         args[4] = dp->rgvarg[1];
 492
 493         TRACE("implicit async\n");
 494
 495         return IDispatchEx_InvokeEx(&dispex->IDispatchEx_iface, DISPID_IHTMLXMLHTTPREQUEST_OPEN,
 496                                     lcid, flags, &new_dp, res, ei, caller);
 497     }
 498
 499     return S_FALSE; /* fallback to default */
 500 }
 501
 502 static HRESULT WINAPI HTMLXMLHttpRequest_open(IHTMLXMLHttpRequest *iface, BSTR bstrMethod, BSTR bstrUrl, VARIANT varAsync, VARIANT varUser, VARIANT varPassword)
 503 {
 504     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 505     nsACString method, url;
 506     nsAString user, password;
 507     nsresult nsres;
 508     HRESULT hres;
 509
 510     TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(bstrMethod), debugstr_w(bstrUrl), debugstr_variant(&varAsync), debugstr_variant(&varUser), debugstr_variant(&varPassword));
 511
 512     if(V_VT(&varAsync) != VT_BOOL) {
 513         FIXME("varAsync not supported: %s\n", debugstr_variant(&varAsync));
 514         return E_FAIL;
 515     }
 516
 517     /* Note: Starting with Gecko 30.0 (Firefox 30.0 / Thunderbird 30.0 / SeaMonkey 2.27),
 518      * synchronous requests on the main thread have been deprecated due to the negative
 519      * effects to the user experience.
 520      */
 521     if(!V_BOOL(&varAsync)) {
 522         FIXME("Synchronous request is not supported yet\n");
 523         return E_FAIL;
 524     }
 525
 526     hres = variant_to_nsastr(varUser, &user);
 527     if(FAILED(hres))
 528         return hres;
 529     hres = variant_to_nsastr(varPassword, &password);
 530     if(FAILED(hres)) {
 531         nsAString_Finish(&user);
 532         return hres;
 533     }
 534
 535     hres = bstr_to_nsacstr(bstrMethod, &method);
 536     if(FAILED(hres)) {
 537         nsAString_Finish(&user);
 538         nsAString_Finish(&password);
 539         return hres;
 540     }
 541     hres = bstr_to_nsacstr(bstrUrl, &url);
 542     if(FAILED(hres)) {
 543         nsAString_Finish(&user);
 544         nsAString_Finish(&password);
 545         nsACString_Finish(&method);
 546         return hres;
 547     }
 548
 549     nsres = nsIXMLHttpRequest_Open(This->nsxhr, &method, &url, TRUE,
 550             &user, &password, 0);
 551
 552     nsACString_Finish(&method);
 553     nsACString_Finish(&url);
 554     nsAString_Finish(&user);
 555     nsAString_Finish(&password);
 556
 557     if(NS_FAILED(nsres)) {
 558         ERR("nsIXMLHttpRequest_Open failed: %08x\n", nsres);
 559         return E_FAIL;
 560     }
 561
 562     return S_OK;
 563 }
 564
 565 static HRESULT WINAPI HTMLXMLHttpRequest_send(IHTMLXMLHttpRequest *iface, VARIANT varBody)
 566 {
 567     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 568     nsIWritableVariant *nsbody = NULL;
 569     nsresult nsres = NS_OK;
 570
 571     TRACE("(%p)->(%s)\n", This, debugstr_variant(&varBody));
 572
 573     switch(V_VT(&varBody)) {
 574     case VT_NULL:
 575     case VT_EMPTY:
 576     case VT_ERROR:
 577         break;
 578     case VT_BSTR: {
 579         nsAString nsstr;
 580
 581         nsbody = create_nsvariant();
 582         if(!nsbody)
 583             return E_OUTOFMEMORY;
 584
 585         nsAString_InitDepend(&nsstr, V_BSTR(&varBody));
 586         nsres = nsIWritableVariant_SetAsAString(nsbody, &nsstr);
 587         nsAString_Finish(&nsstr);
 588         break;
 589     }
 590     default:
 591         FIXME("unsupported body type %s\n", debugstr_variant(&varBody));
 592         return E_NOTIMPL;
 593     }
 594
 595     if(NS_SUCCEEDED(nsres))
 596         nsres = nsIXMLHttpRequest_Send(This->nsxhr, (nsIVariant*)nsbody);
 597     if(nsbody)
 598         nsIWritableVariant_Release(nsbody);
 599     if(NS_FAILED(nsres)) {
 600         ERR("nsIXMLHttpRequest_Send failed: %08x\n", nsres);
 601         return E_FAIL;
 602     }
 603
 604     return S_OK;
 605 }
 606
 607 static HRESULT WINAPI HTMLXMLHttpRequest_getAllResponseHeaders(IHTMLXMLHttpRequest *iface, BSTR *p)
 608 {
 609     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 610     nsACString nscstr;
 611     nsresult nsres;
 612     HRESULT hres;
 613     LONG state;
 614
 615     TRACE("(%p)->(%p)\n", This, p);
 616
 617     if(!p)
 618         return E_POINTER;
 619
 620     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 621     if(FAILED(hres))
 622         return hres;
 623
 624     if(state < 2) {
 625         *p = NULL;
 626         return E_FAIL;
 627     }
 628
 629     nsACString_Init(&nscstr, NULL);
 630     nsres = nsIXMLHttpRequest_GetAllResponseHeaders(This->nsxhr, &nscstr);
 631     return return_nscstr(nsres, &nscstr, p);
 632 }
 633
 634 static HRESULT WINAPI HTMLXMLHttpRequest_getResponseHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR *p)
 635 {
 636     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 637     nsACString header, ret;
 638     char *cstr;
 639     nsresult nsres;
 640     HRESULT hres;
 641     LONG state;
 642     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrHeader), p);
 643
 644     if(!p)
 645         return E_POINTER;
 646     if(!bstrHeader)
 647         return E_INVALIDARG;
 648
 649     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 650     if(FAILED(hres))
 651         return hres;
 652
 653     if(state < 2) {
 654         *p = NULL;
 655         return E_FAIL;
 656     }
 657
 658     cstr = heap_strdupWtoU(bstrHeader);
 659     nsACString_InitDepend(&header, cstr);
 660     nsACString_Init(&ret, NULL);
 661
 662     nsres = nsIXMLHttpRequest_GetResponseHeader(This->nsxhr, &header, &ret);
 663
 664     nsACString_Finish(&header);
 665     heap_free(cstr);
 666     return return_nscstr(nsres, &ret, p);
 667 }
 668
 669 static HRESULT WINAPI HTMLXMLHttpRequest_setRequestHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR bstrValue)
 670 {
 671     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 672     char *header_u, *value_u;
 673     nsACString header, value;
 674     nsresult nsres;
 675
 676     TRACE("(%p)->(%s %s)\n", This, debugstr_w(bstrHeader), debugstr_w(bstrValue));
 677
 678     header_u = heap_strdupWtoU(bstrHeader);
 679     if(bstrHeader && !header_u)
 680         return E_OUTOFMEMORY;
 681
 682     value_u = heap_strdupWtoU(bstrValue);
 683     if(bstrValue && !value_u) {
 684         heap_free(header_u);
 685         return E_OUTOFMEMORY;
 686     }
 687
 688     nsACString_InitDepend(&header, header_u);
 689     nsACString_InitDepend(&value, value_u);
 690     nsres = nsIXMLHttpRequest_SetRequestHeader(This->nsxhr, &header, &value);
 691     nsACString_Finish(&header);
 692     nsACString_Finish(&value);
 693     heap_free(header_u);
 694     heap_free(value_u);
 695     if(NS_FAILED(nsres)) {
 696         ERR("SetRequestHeader failed: %08x\n", nsres);
 697         return E_FAIL;
 698     }
 699
 700     return S_OK;
 701 }
 702
 703 static const IHTMLXMLHttpRequestVtbl HTMLXMLHttpRequestVtbl = {
 704     HTMLXMLHttpRequest_QueryInterface,
 705     HTMLXMLHttpRequest_AddRef,
 706     HTMLXMLHttpRequest_Release,
 707     HTMLXMLHttpRequest_GetTypeInfoCount,
 708     HTMLXMLHttpRequest_GetTypeInfo,
 709     HTMLXMLHttpRequest_GetIDsOfNames,
 710     HTMLXMLHttpRequest_Invoke,
 711     HTMLXMLHttpRequest_get_readyState,
 712     HTMLXMLHttpRequest_get_responseBody,
 713     HTMLXMLHttpRequest_get_responseText,
 714     HTMLXMLHttpRequest_get_responseXML,
 715     HTMLXMLHttpRequest_get_status,
 716     HTMLXMLHttpRequest_get_statusText,
 717     HTMLXMLHttpRequest_put_onreadystatechange,
 718     HTMLXMLHttpRequest_get_onreadystatechange,
 719     HTMLXMLHttpRequest_abort,
 720     HTMLXMLHttpRequest_open,
 721     HTMLXMLHttpRequest_send,
 722     HTMLXMLHttpRequest_getAllResponseHeaders,
 723     HTMLXMLHttpRequest_getResponseHeader,
 724     HTMLXMLHttpRequest_setRequestHeader
 725 };
 726
 727 static inline HTMLXMLHttpRequest *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface)
 728 {
 729     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IProvideClassInfo2_iface);
 730 }
 731
 732 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
 733 {
 734     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 735     return IHTMLXMLHttpRequest_QueryInterface(&This->IHTMLXMLHttpRequest_iface, riid, ppv);
 736 }
 737
 738 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideClassInfo2 *iface)
 739 {
 740     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 741     return IHTMLXMLHttpRequest_AddRef(&This->IHTMLXMLHttpRequest_iface);
 742 }
 743
 744 static ULONG WINAPI ProvideClassInfo_Release(IProvideClassInfo2 *iface)
 745 {
 746     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 747     return IHTMLXMLHttpRequest_Release(&This->IHTMLXMLHttpRequest_iface);
 748 }
 749
 750 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI)
 751 {
 752     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 753     TRACE("(%p)->(%p)\n", This, ppTI);
 754     return get_class_typeinfo(&CLSID_HTMLXMLHttpRequest, ppTI);
 755 }
 756
 757 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
 758 {
 759     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
 760     FIXME("(%p)->(%u %p)\n", This, dwGuidKind, pGUID);
 761     return E_NOTIMPL;
 762 }
 763
 764 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
 765     ProvideClassInfo_QueryInterface,
 766     ProvideClassInfo_AddRef,
 767     ProvideClassInfo_Release,
 768     ProvideClassInfo_GetClassInfo,
 769     ProvideClassInfo2_GetGUID,
 770 };
 771
 772 static inline HTMLXMLHttpRequest *impl_from_DispatchEx(DispatchEx *iface)
 773 {
 774     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, event_target.dispex);
 775 }
 776
 777 static HRESULT HTMLXMLHttpRequest_get_dispid(DispatchEx *dispex, BSTR name, DWORD flags, DISPID *dispid)
 778 {
 779     /* onload event handler property is supported, but not exposed by any interface. We implement as a custom property. */
 780     if(!wcscmp(L"onload", name)) {
 781         *dispid = MSHTML_DISPID_HTMLXMLHTTPREQUEST_ONLOAD;
 782         return S_OK;
 783     }
 784
 785     return DISP_E_UNKNOWNNAME;
 786 }
 787
 788 static HRESULT HTMLXMLHttpRequest_invoke(DispatchEx *dispex, DISPID id, LCID lcid, WORD flags, DISPPARAMS *params,
 789         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 790 {
 791     HTMLXMLHttpRequest *This = impl_from_DispatchEx(dispex);
 792
 793     if(id == MSHTML_DISPID_HTMLXMLHTTPREQUEST_ONLOAD) {
 794         switch(flags) {
 795         case DISPATCH_PROPERTYGET:
 796             TRACE("(%p) get onload\n", This);
 797             return get_event_handler(&This->event_target, EVENTID_LOAD, res);
 798
 799         case DISPATCH_PROPERTYPUT:
 800             if(params->cArgs != 1 || (params->cNamedArgs == 1 && *params->rgdispidNamedArgs != DISPID_PROPERTYPUT)
 801                || params->cNamedArgs > 1) {
 802                 FIXME("invalid args\n");
 803                 return E_INVALIDARG;
 804             }
 805
 806             TRACE("(%p)->(%p) set onload\n", This, params->rgvarg);
 807             return set_event_handler(&This->event_target, EVENTID_LOAD, params->rgvarg);
 808
 809         default:
 810             FIXME("Unimplemented flags %x\n", flags);
 811             return E_NOTIMPL;
 812         }
 813     }
 814
 815     return DISP_E_UNKNOWNNAME;
 816 }
 817
 818 static nsISupports *HTMLXMLHttpRequest_get_gecko_target(DispatchEx *dispex)
 819 {
 820     HTMLXMLHttpRequest *This = impl_from_DispatchEx(dispex);
 821     return (nsISupports*)This->nsxhr;
 822 }
 823
 824 static void HTMLXMLHttpRequest_bind_event(DispatchEx *dispex, eventid_t eid)
 825 {
 826     HTMLXMLHttpRequest *This = impl_from_DispatchEx(dispex);
 827     nsIDOMEventTarget *nstarget;
 828     const WCHAR *type_name;
 829     nsAString type_str;
 830     nsresult nsres;
 831
 832     TRACE("(%p)\n", This);
 833
 834     switch(eid) {
 835     case EVENTID_READYSTATECHANGE:
 836         type_name = L"readystatechange";
 837         break;
 838     case EVENTID_LOAD:
 839         type_name = L"load";
 840         break;
 841     default:
 842         return;
 843     }
 844
 845     if(!This->event_listener) {
 846         This->event_listener = heap_alloc(sizeof(*This->event_listener));
 847         if(!This->event_listener)
 848             return;
 849
 850         This->event_listener->nsIDOMEventListener_iface.lpVtbl = &XMLHttpReqEventListenerVtbl;
 851         This->event_listener->ref = 1;
 852         This->event_listener->xhr = This;
 853         This->event_listener->readystatechange_event = FALSE;
 854         This->event_listener->load_event = FALSE;
 855     }
 856
 857     nsres = nsIXMLHttpRequest_QueryInterface(This->nsxhr, &IID_nsIDOMEventTarget, (void**)&nstarget);
 858     assert(nsres == NS_OK);
 859
 860     nsAString_InitDepend(&type_str, type_name);
 861     nsres = nsIDOMEventTarget_AddEventListener(nstarget, &type_str, &This->event_listener->nsIDOMEventListener_iface, FALSE, TRUE, 2);
 862     nsAString_Finish(&type_str);
 863     if(NS_FAILED(nsres))
 864         ERR("AddEventListener(%s) failed: %08x\n", debugstr_w(type_name), nsres);
 865
 866     nsIDOMEventTarget_Release(nstarget);
 867
 868     if(eid == EVENTID_READYSTATECHANGE)
 869         This->event_listener->readystatechange_event = TRUE;
 870     else
 871         This->event_listener->load_event = TRUE;
 872 }
 873
 874 static void HTMLXMLHttpRequest_init_dispex_info(dispex_data_t *info, compat_mode_t compat_mode)
 875 {
 876     static const dispex_hook_t xhr_hooks[] = {
 877         {DISPID_IHTMLXMLHTTPREQUEST_OPEN, HTMLXMLHttpRequest_open_hook},
 878         {DISPID_UNKNOWN}
 879     };
 880
 881     EventTarget_init_dispex_info(info, compat_mode);
 882     dispex_info_add_interface(info, IHTMLXMLHttpRequest_tid, compat_mode >= COMPAT_MODE_IE10 ? xhr_hooks : NULL);
 883 }
 884
 885 static event_target_vtbl_t HTMLXMLHttpRequest_event_target_vtbl = {
 886     {
 887         NULL,
 888         HTMLXMLHttpRequest_get_dispid,
 889         HTMLXMLHttpRequest_invoke
 890     },
 891     HTMLXMLHttpRequest_get_gecko_target,
 892     HTMLXMLHttpRequest_bind_event
 893 };
 894
 895 static const tid_t HTMLXMLHttpRequest_iface_tids[] = {
 896     0
 897 };
 898 static dispex_static_data_t HTMLXMLHttpRequest_dispex = {
 899     &HTMLXMLHttpRequest_event_target_vtbl.dispex_vtbl,
 900     DispHTMLXMLHttpRequest_tid,
 901     HTMLXMLHttpRequest_iface_tids,
 902     HTMLXMLHttpRequest_init_dispex_info
 903 };
 904
 905
 906 /* IHTMLXMLHttpRequestFactory */
 907 static inline HTMLXMLHttpRequestFactory *impl_from_IHTMLXMLHttpRequestFactory(IHTMLXMLHttpRequestFactory *iface)
 908 {
 909     return CONTAINING_RECORD(iface, HTMLXMLHttpRequestFactory, IHTMLXMLHttpRequestFactory_iface);
 910 }
 911
 912 static HRESULT WINAPI HTMLXMLHttpRequestFactory_QueryInterface(IHTMLXMLHttpRequestFactory *iface, REFIID riid, void **ppv)
 913 {
 914     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 915
 916     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 917
 918     if(IsEqualGUID(&IID_IUnknown, riid)) {
 919         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
 920     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 921         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
 922     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequestFactory, riid)) {
 923         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
 924     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 925         return *ppv ? S_OK : E_NOINTERFACE;
 926     }else {
 927         *ppv = NULL;
 928         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 929         return E_NOINTERFACE;
 930     }
 931
 932     IUnknown_AddRef((IUnknown*)*ppv);
 933     return S_OK;
 934 }
 935
 936 static ULONG WINAPI HTMLXMLHttpRequestFactory_AddRef(IHTMLXMLHttpRequestFactory *iface)
 937 {
 938     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 939     LONG ref = InterlockedIncrement(&This->ref);
 940
 941     TRACE("(%p) ref=%d\n", This, ref);
 942
 943     return ref;
 944 }
 945
 946 static ULONG WINAPI HTMLXMLHttpRequestFactory_Release(IHTMLXMLHttpRequestFactory *iface)
 947 {
 948     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 949     LONG ref = InterlockedDecrement(&This->ref);
 950
 951     TRACE("(%p) ref=%d\n", This, ref);
 952
 953     if(!ref) {
 954         release_dispex(&This->dispex);
 955         heap_free(This);
 956     }
 957
 958     return ref;
 959 }
 960
 961 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetTypeInfoCount(IHTMLXMLHttpRequestFactory *iface, UINT *pctinfo)
 962 {
 963     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 964     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 965 }
 966
 967 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetTypeInfo(IHTMLXMLHttpRequestFactory *iface, UINT iTInfo,
 968         LCID lcid, ITypeInfo **ppTInfo)
 969 {
 970     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 971
 972     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 973 }
 974
 975 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetIDsOfNames(IHTMLXMLHttpRequestFactory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 976         LCID lcid, DISPID *rgDispId)
 977 {
 978     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 979
 980     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 981             lcid, rgDispId);
 982 }
 983
 984 static HRESULT WINAPI HTMLXMLHttpRequestFactory_Invoke(IHTMLXMLHttpRequestFactory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 985         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 986 {
 987     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 988
 989     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 990             pDispParams, pVarResult, pExcepInfo, puArgErr);
 991 }
 992
 993 static HRESULT WINAPI HTMLXMLHttpRequestFactory_create(IHTMLXMLHttpRequestFactory *iface, IHTMLXMLHttpRequest **p)
 994 {
 995     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
 996     HTMLXMLHttpRequest        *ret;
 997     nsIXMLHttpRequest         *nsxhr;
 998
 999     TRACE("(%p)->(%p)\n", This, p);
1000
1001     nsxhr = create_nsxhr(This->window->base.outer_window->nswindow);
1002     if(!nsxhr)
1003         return E_FAIL;
1004
1005     ret = heap_alloc_zero(sizeof(*ret));
1006     if(!ret) {
1007         nsIXMLHttpRequest_Release(nsxhr);
1008         return E_OUTOFMEMORY;
1009     }
1010     ret->nsxhr = nsxhr;
1011
1012     ret->IHTMLXMLHttpRequest_iface.lpVtbl = &HTMLXMLHttpRequestVtbl;
1013     ret->IProvideClassInfo2_iface.lpVtbl = &ProvideClassInfo2Vtbl;
1014     EventTarget_Init(&ret->event_target, (IUnknown*)&ret->IHTMLXMLHttpRequest_iface,
1015                      &HTMLXMLHttpRequest_dispex, This->window->doc->document_mode);
1016     ret->ref = 1;
1017
1018     *p = &ret->IHTMLXMLHttpRequest_iface;
1019     return S_OK;
1020 }
1021
1022 static const IHTMLXMLHttpRequestFactoryVtbl HTMLXMLHttpRequestFactoryVtbl = {
1023     HTMLXMLHttpRequestFactory_QueryInterface,
1024     HTMLXMLHttpRequestFactory_AddRef,
1025     HTMLXMLHttpRequestFactory_Release,
1026     HTMLXMLHttpRequestFactory_GetTypeInfoCount,
1027     HTMLXMLHttpRequestFactory_GetTypeInfo,
1028     HTMLXMLHttpRequestFactory_GetIDsOfNames,
1029     HTMLXMLHttpRequestFactory_Invoke,
1030     HTMLXMLHttpRequestFactory_create
1031 };
1032
1033 static inline HTMLXMLHttpRequestFactory *factory_from_DispatchEx(DispatchEx *iface)
1034 {
1035     return CONTAINING_RECORD(iface, HTMLXMLHttpRequestFactory, dispex);
1036 }
1037
1038 static HRESULT HTMLXMLHttpRequestFactory_value(DispatchEx *iface, LCID lcid, WORD flags, DISPPARAMS *params,
1039         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1040 {
1041     HTMLXMLHttpRequestFactory *This = factory_from_DispatchEx(iface);
1042     IHTMLXMLHttpRequest *xhr;
1043     HRESULT hres;
1044
1045     TRACE("\n");
1046
1047     if(flags != DISPATCH_CONSTRUCT) {
1048         FIXME("flags %x not supported\n", flags);
1049         return E_NOTIMPL;
1050     }
1051
1052     hres = IHTMLXMLHttpRequestFactory_create(&This->IHTMLXMLHttpRequestFactory_iface, &xhr);
1053     if(FAILED(hres))
1054         return hres;
1055
1056     V_VT(res) = VT_DISPATCH;
1057     V_DISPATCH(res) = (IDispatch*)xhr;
1058     return S_OK;
1059 }
1060
1061 static const dispex_static_data_vtbl_t HTMLXMLHttpRequestFactory_dispex_vtbl = {
1062     HTMLXMLHttpRequestFactory_value
1063 };
1064
1065 static const tid_t HTMLXMLHttpRequestFactory_iface_tids[] = {
1066     IHTMLXMLHttpRequestFactory_tid,
1067     0
1068 };
1069 static dispex_static_data_t HTMLXMLHttpRequestFactory_dispex = {
1070     &HTMLXMLHttpRequestFactory_dispex_vtbl,
1071     IHTMLXMLHttpRequestFactory_tid,
1072     HTMLXMLHttpRequestFactory_iface_tids
1073 };
1074
1075 HRESULT HTMLXMLHttpRequestFactory_Create(HTMLInnerWindow* window, HTMLXMLHttpRequestFactory **ret_ptr)
1076 {
1077     HTMLXMLHttpRequestFactory *ret;
1078
1079     ret = heap_alloc(sizeof(*ret));
1080     if(!ret)
1081         return E_OUTOFMEMORY;
1082
1083     ret->IHTMLXMLHttpRequestFactory_iface.lpVtbl = &HTMLXMLHttpRequestFactoryVtbl;
1084     ret->ref = 1;
1085     ret->window = window;
1086
1087     init_dispatch(&ret->dispex, (IUnknown*)&ret->IHTMLXMLHttpRequestFactory_iface,
1088                   &HTMLXMLHttpRequestFactory_dispex, dispex_compat_mode(&window->event_target.dispex));
1089
1090     *ret_ptr = ret;
1091     return S_OK;
1092 }