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
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31 #include "htmlevent.h"
  32 #include "mshtmdid.h"
  33 #include "initguid.h"
  34 #include "msxml6.h"
  35 #include "objsafe.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  38
  39 static HRESULT bstr_to_nsacstr(BSTR bstr, nsACString *str)
  40 {
  41     char *cstr = strdupWtoU(bstr);
  42     if(!cstr)
  43         return E_OUTOFMEMORY;
  44     nsACString_Init(str, cstr);
  45     free(cstr);
  46     return S_OK;
  47 }
  48
  49 static HRESULT variant_to_nsastr(VARIANT var, nsAString *ret)
  50 {
  51     switch(V_VT(&var)) {
  52         case VT_NULL:
  53         case VT_ERROR:
  54         case VT_EMPTY:
  55             nsAString_Init(ret, NULL);
  56             return S_OK;
  57         case VT_BSTR:
  58             nsAString_InitDepend(ret, V_BSTR(&var));
  59             return S_OK;
  60         default:
  61             FIXME("Unsupported VARIANT: %s\n", debugstr_variant(&var));
  62             return E_INVALIDARG;
  63     }
  64 }
  65
  66 static HRESULT return_nscstr(nsresult nsres, nsACString *nscstr, BSTR *p)
  67 {
  68     const char *str;
  69     int len;
  70
  71     if(NS_FAILED(nsres)) {
  72         ERR("failed: %08lx\n", nsres);
  73         nsACString_Finish(nscstr);
  74         return E_FAIL;
  75     }
  76
  77     nsACString_GetData(nscstr, &str);
  78
  79     if(*str) {
  80         len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
  81         *p = SysAllocStringLen(NULL, len - 1);
  82         if(!*p) {
  83             nsACString_Finish(nscstr);
  84             return E_OUTOFMEMORY;
  85         }
  86         MultiByteToWideChar(CP_UTF8, 0, str, -1, *p, len);
  87     }else {
  88         *p = NULL;
  89     }
  90
  91     nsACString_Finish(nscstr);
  92     return S_OK;
  93 }
  94
  95 static const eventid_t events[] = {
  96     EVENTID_READYSTATECHANGE,
  97     EVENTID_LOAD,
  98     EVENTID_LOADSTART,
  99     EVENTID_LOADEND,
 100     EVENTID_PROGRESS,
 101     EVENTID_ABORT,
 102     EVENTID_ERROR,
 103     EVENTID_TIMEOUT,
 104 };
 105
 106 typedef enum {
 107     response_type_empty,
 108     response_type_text,
 109     response_type_doc,
 110     response_type_arraybuf,
 111     response_type_blob,
 112     response_type_stream
 113 } response_type_t;
 114
 115 static const struct {
 116     const WCHAR *str;
 117     const WCHAR *nsxhr_str;
 118 } response_type_desc[] = {
 119     [response_type_empty]       = { L"",            L"" },
 120     [response_type_text]        = { L"text",        L"" },
 121     [response_type_doc]         = { L"document",    L"" }, /* FIXME */
 122     [response_type_arraybuf]    = { L"arraybuffer", L"arraybuffer" },
 123     [response_type_blob]        = { L"blob",        L"arraybuffer" },
 124     [response_type_stream]      = { L"ms-stream",   L"arraybuffer" } /* FIXME */
 125 };
 126
 127 typedef struct {
 128     nsIDOMEventListener nsIDOMEventListener_iface;
 129     LONG ref;
 130     HTMLXMLHttpRequest *xhr;
 131     DWORD events_mask;
 132 } XMLHttpReqEventListener;
 133
 134 struct HTMLXMLHttpRequest {
 135     EventTarget event_target;
 136     IHTMLXMLHttpRequest IHTMLXMLHttpRequest_iface;
 137     IHTMLXMLHttpRequest2 IHTMLXMLHttpRequest2_iface;
 138     IWineXMLHttpRequestPrivate IWineXMLHttpRequestPrivate_iface;
 139     IProvideClassInfo2 IProvideClassInfo2_iface;
 140     LONG ref;
 141     response_type_t response_type;
 142     nsIXMLHttpRequest *nsxhr;
 143     XMLHttpReqEventListener *event_listener;
 144 };
 145
 146 static void detach_xhr_event_listener(XMLHttpReqEventListener *event_listener)
 147 {
 148     nsIDOMEventTarget *event_target;
 149     DWORD events_mask, i;
 150     nsAString str;
 151     nsresult nsres;
 152
 153     nsres = nsIXMLHttpRequest_QueryInterface(event_listener->xhr->nsxhr, &IID_nsIDOMEventTarget, (void**)&event_target);
 154     assert(nsres == NS_OK);
 155
 156     for(events_mask = event_listener->events_mask, i = 0; events_mask; events_mask >>= 1, i++) {
 157         if(!(events_mask & 1))
 158             continue;
 159         nsAString_InitDepend(&str, get_event_name(events[i]));
 160         nsres = nsIDOMEventTarget_RemoveEventListener(event_target, &str, &event_listener->nsIDOMEventListener_iface, FALSE);
 161         nsAString_Finish(&str);
 162         assert(nsres == NS_OK);
 163     }
 164
 165     nsIDOMEventTarget_Release(event_target);
 166
 167     event_listener->xhr->event_listener = NULL;
 168     event_listener->xhr = NULL;
 169     nsIDOMEventListener_Release(&event_listener->nsIDOMEventListener_iface);
 170 }
 171
 172
 173 static inline XMLHttpReqEventListener *impl_from_nsIDOMEventListener(nsIDOMEventListener *iface)
 174 {
 175     return CONTAINING_RECORD(iface, XMLHttpReqEventListener, nsIDOMEventListener_iface);
 176 }
 177
 178 static nsresult NSAPI XMLHttpReqEventListener_QueryInterface(nsIDOMEventListener *iface,
 179         nsIIDRef riid, void **result)
 180 {
 181     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 182
 183     if(IsEqualGUID(&IID_nsISupports, riid)) {
 184         TRACE("(%p)->(IID_nsISupports, %p)\n", This, result);
 185         *result = &This->nsIDOMEventListener_iface;
 186     }else if(IsEqualGUID(&IID_nsIDOMEventListener, riid)) {
 187         TRACE("(%p)->(IID_nsIDOMEventListener %p)\n", This, result);
 188         *result = &This->nsIDOMEventListener_iface;
 189     }else {
 190         *result = NULL;
 191         TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), result);
 192         return NS_NOINTERFACE;
 193     }
 194
 195     nsIDOMEventListener_AddRef(&This->nsIDOMEventListener_iface);
 196     return NS_OK;
 197 }
 198
 199 static nsrefcnt NSAPI XMLHttpReqEventListener_AddRef(nsIDOMEventListener *iface)
 200 {
 201     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 202     LONG ref = InterlockedIncrement(&This->ref);
 203
 204     TRACE("(%p) ref=%ld\n", This, ref);
 205
 206     return ref;
 207 }
 208
 209 static nsrefcnt NSAPI XMLHttpReqEventListener_Release(nsIDOMEventListener *iface)
 210 {
 211     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 212     LONG ref = InterlockedDecrement(&This->ref);
 213
 214     TRACE("(%p) ref=%ld\n", This, ref);
 215
 216     if(!ref) {
 217         assert(!This->xhr);
 218         free(This);
 219     }
 220
 221     return ref;
 222 }
 223
 224 static nsresult NSAPI XMLHttpReqEventListener_HandleEvent(nsIDOMEventListener *iface, nsIDOMEvent *nsevent)
 225 {
 226     XMLHttpReqEventListener *This = impl_from_nsIDOMEventListener(iface);
 227     DOMEvent *event;
 228     HRESULT hres;
 229
 230     TRACE("(%p)\n", This);
 231
 232     if(!This->xhr)
 233         return NS_OK;
 234
 235     hres = create_event_from_nsevent(nsevent, dispex_compat_mode(&This->xhr->event_target.dispex), &event);
 236     if(SUCCEEDED(hres) ){
 237         dispatch_event(&This->xhr->event_target, event);
 238         IDOMEvent_Release(&event->IDOMEvent_iface);
 239     }
 240     return NS_OK;
 241 }
 242
 243 static const nsIDOMEventListenerVtbl XMLHttpReqEventListenerVtbl = {
 244     XMLHttpReqEventListener_QueryInterface,
 245     XMLHttpReqEventListener_AddRef,
 246     XMLHttpReqEventListener_Release,
 247     XMLHttpReqEventListener_HandleEvent
 248 };
 249
 250 static inline HTMLXMLHttpRequest *impl_from_IHTMLXMLHttpRequest(IHTMLXMLHttpRequest *iface)
 251 {
 252     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IHTMLXMLHttpRequest_iface);
 253 }
 254
 255 static HRESULT WINAPI HTMLXMLHttpRequest_QueryInterface(IHTMLXMLHttpRequest *iface, REFIID riid, void **ppv)
 256 {
 257     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 258
 259     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 260
 261     if(IsEqualGUID(&IID_IUnknown, riid)) {
 262         *ppv = &This->IHTMLXMLHttpRequest_iface;
 263     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
 264         *ppv = &This->IHTMLXMLHttpRequest_iface;
 265     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequest, riid)) {
 266         *ppv = &This->IHTMLXMLHttpRequest_iface;
 267     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequest2, riid)) {
 268         *ppv = &This->IHTMLXMLHttpRequest2_iface;
 269     }else if(IsEqualGUID(&IID_IWineXMLHttpRequestPrivate, riid)) {
 270         *ppv = &This->IWineXMLHttpRequestPrivate_iface;
 271     }else if(IsEqualGUID(&IID_IProvideClassInfo, riid)) {
 272         *ppv = &This->IProvideClassInfo2_iface;
 273     }else if(IsEqualGUID(&IID_IProvideClassInfo2, riid)) {
 274         *ppv = &This->IProvideClassInfo2_iface;
 275     }else {
 276         return EventTarget_QI(&This->event_target, riid, ppv);
 277     }
 278
 279     IUnknown_AddRef((IUnknown*)*ppv);
 280     return S_OK;
 281 }
 282
 283 static ULONG WINAPI HTMLXMLHttpRequest_AddRef(IHTMLXMLHttpRequest *iface)
 284 {
 285     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 286     LONG ref = InterlockedIncrement(&This->ref);
 287
 288     TRACE("(%p) ref=%ld\n", This, ref);
 289
 290     return ref;
 291 }
 292
 293 static ULONG WINAPI HTMLXMLHttpRequest_Release(IHTMLXMLHttpRequest *iface)
 294 {
 295     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 296     LONG ref = InterlockedDecrement(&This->ref);
 297
 298     TRACE("(%p) ref=%ld\n", This, ref);
 299
 300     if(!ref) {
 301         if(This->event_listener)
 302             detach_xhr_event_listener(This->event_listener);
 303         release_event_target(&This->event_target);
 304         release_dispex(&This->event_target.dispex);
 305         nsIXMLHttpRequest_Release(This->nsxhr);
 306         free(This);
 307     }
 308
 309     return ref;
 310 }
 311
 312 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfoCount(IHTMLXMLHttpRequest *iface, UINT *pctinfo)
 313 {
 314     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 315     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
 316 }
 317
 318 static HRESULT WINAPI HTMLXMLHttpRequest_GetTypeInfo(IHTMLXMLHttpRequest *iface, UINT iTInfo,
 319         LCID lcid, ITypeInfo **ppTInfo)
 320 {
 321     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 322
 323     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 324 }
 325
 326 static HRESULT WINAPI HTMLXMLHttpRequest_GetIDsOfNames(IHTMLXMLHttpRequest *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 327         LCID lcid, DISPID *rgDispId)
 328 {
 329     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 330
 331     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 332             lcid, rgDispId);
 333 }
 334
 335 static HRESULT WINAPI HTMLXMLHttpRequest_Invoke(IHTMLXMLHttpRequest *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 336         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 337 {
 338     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 339
 340     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 341             pDispParams, pVarResult, pExcepInfo, puArgErr);
 342 }
 343
 344 static HRESULT WINAPI HTMLXMLHttpRequest_get_readyState(IHTMLXMLHttpRequest *iface, LONG *p)
 345 {
 346     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 347     UINT16 val;
 348     nsresult nsres;
 349
 350     TRACE("(%p)->(%p)\n", This, p);
 351
 352     if(!p)
 353         return E_POINTER;
 354     nsres = nsIXMLHttpRequest_GetReadyState(This->nsxhr, &val);
 355     if(NS_FAILED(nsres)) {
 356         ERR("nsIXMLHttpRequest_GetReadyState failed: %08lx\n", nsres);
 357         return E_FAIL;
 358     }
 359     *p = val;
 360     return S_OK;
 361 }
 362
 363 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseBody(IHTMLXMLHttpRequest *iface, VARIANT *p)
 364 {
 365     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 366     FIXME("(%p)->(%p)\n", This, p);
 367     return E_NOTIMPL;
 368 }
 369
 370 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseText(IHTMLXMLHttpRequest *iface, BSTR *p)
 371 {
 372     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 373     nsAString nsstr;
 374     nsresult nsres;
 375
 376     TRACE("(%p)->(%p)\n", This, p);
 377
 378     if(!p)
 379         return E_POINTER;
 380
 381     nsAString_Init(&nsstr, NULL);
 382     nsres = nsIXMLHttpRequest_GetResponseText(This->nsxhr, &nsstr);
 383     return return_nsstr(nsres, &nsstr, p);
 384 }
 385
 386 static HRESULT WINAPI HTMLXMLHttpRequest_get_responseXML(IHTMLXMLHttpRequest *iface, IDispatch **p)
 387 {
 388     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 389     IXMLDOMDocument *xmldoc = NULL;
 390     BSTR str;
 391     HRESULT hres;
 392     VARIANT_BOOL vbool;
 393     IObjectSafety *safety;
 394
 395     TRACE("(%p)->(%p)\n", This, p);
 396
 397     if(dispex_compat_mode(&This->event_target.dispex) >= COMPAT_MODE_IE10) {
 398         nsIDOMDocument *nsdoc;
 399         nsresult nsres;
 400
 401         nsres = nsIXMLHttpRequest_GetResponseXML(This->nsxhr, &nsdoc);
 402         if(NS_FAILED(nsres))
 403             return map_nsresult(nsres);
 404         if(!nsdoc) {
 405             *p = NULL;
 406             return S_OK;
 407         }
 408         nsIDOMDocument_Release(nsdoc);
 409     }
 410
 411     hres = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER, &IID_IXMLDOMDocument, (void**)&xmldoc);
 412     if(FAILED(hres)) {
 413         ERR("CoCreateInstance failed: %08lx\n", hres);
 414         return hres;
 415     }
 416
 417     hres = IHTMLXMLHttpRequest_get_responseText(iface, &str);
 418     if(FAILED(hres)) {
 419         IXMLDOMDocument_Release(xmldoc);
 420         ERR("get_responseText failed: %08lx\n", hres);
 421         return hres;
 422     }
 423
 424     hres = IXMLDOMDocument_loadXML(xmldoc, str, &vbool);
 425     SysFreeString(str);
 426     if(hres != S_OK || vbool != VARIANT_TRUE)
 427         WARN("loadXML failed: %08lx, returning an empty xmldoc\n", hres);
 428
 429     hres = IXMLDOMDocument_QueryInterface(xmldoc, &IID_IObjectSafety, (void**)&safety);
 430     assert(SUCCEEDED(hres));
 431     hres = IObjectSafety_SetInterfaceSafetyOptions(safety, NULL,
 432         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER,
 433         INTERFACESAFE_FOR_UNTRUSTED_CALLER | INTERFACESAFE_FOR_UNTRUSTED_DATA | INTERFACE_USES_SECURITY_MANAGER);
 434     assert(SUCCEEDED(hres));
 435     IObjectSafety_Release(safety);
 436
 437     *p = (IDispatch*)xmldoc;
 438     return S_OK;
 439 }
 440
 441 static HRESULT WINAPI HTMLXMLHttpRequest_get_status(IHTMLXMLHttpRequest *iface, LONG *p)
 442 {
 443     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 444     UINT32 val;
 445     nsresult nsres;
 446     TRACE("(%p)->(%p)\n", This, p);
 447
 448     if(!p)
 449         return E_POINTER;
 450
 451     nsres = nsIXMLHttpRequest_GetStatus(This->nsxhr, &val);
 452     if(NS_FAILED(nsres)) {
 453         ERR("nsIXMLHttpRequest_GetStatus failed: %08lx\n", nsres);
 454         return E_FAIL;
 455     }
 456     *p = val;
 457     if(val == 0)
 458         return E_FAIL; /* WinAPI thinks this is an error */
 459
 460     return S_OK;
 461 }
 462
 463 static HRESULT WINAPI HTMLXMLHttpRequest_get_statusText(IHTMLXMLHttpRequest *iface, BSTR *p)
 464 {
 465     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 466     nsACString nscstr;
 467     nsresult nsres;
 468     HRESULT hres;
 469     LONG state;
 470
 471     TRACE("(%p)->(%p)\n", This, p);
 472
 473     if(!p)
 474         return E_POINTER;
 475
 476     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 477     if(FAILED(hres))
 478         return hres;
 479
 480     if(state < 2) {
 481         *p = NULL;
 482         return E_FAIL;
 483     }
 484
 485     nsACString_Init(&nscstr, NULL);
 486     nsres = nsIXMLHttpRequest_GetStatusText(This->nsxhr, &nscstr);
 487     return return_nscstr(nsres, &nscstr, p);
 488 }
 489
 490 static HRESULT WINAPI HTMLXMLHttpRequest_put_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT v)
 491 {
 492     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 493
 494     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 495
 496     return set_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, &v);
 497 }
 498
 499 static HRESULT WINAPI HTMLXMLHttpRequest_get_onreadystatechange(IHTMLXMLHttpRequest *iface, VARIANT *p)
 500 {
 501     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 502
 503     TRACE("(%p)->(%p)\n", This, p);
 504
 505     return get_event_handler(&This->event_target, EVENTID_READYSTATECHANGE, p);
 506 }
 507
 508 static HRESULT WINAPI HTMLXMLHttpRequest_abort(IHTMLXMLHttpRequest *iface)
 509 {
 510     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 511     nsresult nsres;
 512
 513     TRACE("(%p)->()\n", This);
 514
 515     nsres = nsIXMLHttpRequest_SlowAbort(This->nsxhr);
 516     if(NS_FAILED(nsres)) {
 517         ERR("nsIXMLHttpRequest_SlowAbort failed: %08lx\n", nsres);
 518         return E_FAIL;
 519     }
 520
 521     return S_OK;
 522 }
 523
 524 static HRESULT HTMLXMLHttpRequest_open_hook(DispatchEx *dispex, WORD flags,
 525         DISPPARAMS *dp, VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
 526 {
 527     /* If only two arguments were given, implicitly set async to false */
 528     if((flags & DISPATCH_METHOD) && dp->cArgs == 2 && !dp->cNamedArgs) {
 529         VARIANT args[5];
 530         DISPPARAMS new_dp = {args, NULL, ARRAY_SIZE(args), 0};
 531         V_VT(args) = VT_EMPTY;
 532         V_VT(args+1) = VT_EMPTY;
 533         V_VT(args+2) = VT_BOOL;
 534         V_BOOL(args+2) = VARIANT_TRUE;
 535         args[3] = dp->rgvarg[0];
 536         args[4] = dp->rgvarg[1];
 537
 538         TRACE("implicit async\n");
 539
 540         return dispex_call_builtin(dispex, DISPID_IHTMLXMLHTTPREQUEST_OPEN, &new_dp, res, ei, caller);
 541     }
 542
 543     return S_FALSE; /* fallback to default */
 544 }
 545
 546 static HRESULT WINAPI HTMLXMLHttpRequest_open(IHTMLXMLHttpRequest *iface, BSTR bstrMethod, BSTR bstrUrl, VARIANT varAsync, VARIANT varUser, VARIANT varPassword)
 547 {
 548     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 549     nsACString method, url;
 550     nsAString user, password;
 551     nsresult nsres;
 552     HRESULT hres;
 553
 554     TRACE("(%p)->(%s %s %s %s %s)\n", This, debugstr_w(bstrMethod), debugstr_w(bstrUrl), debugstr_variant(&varAsync), debugstr_variant(&varUser), debugstr_variant(&varPassword));
 555
 556     if(V_VT(&varAsync) != VT_BOOL) {
 557         LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT);
 558         hres = VariantChangeTypeEx(&varAsync, &varAsync, lcid, 0, VT_BOOL);
 559         if(FAILED(hres)) {
 560             WARN("Failed to convert varAsync to BOOL: %#lx\n", hres);
 561             return hres;
 562         }
 563     }
 564
 565     /* Note: Starting with Gecko 30.0 (Firefox 30.0 / Thunderbird 30.0 / SeaMonkey 2.27),
 566      * synchronous requests on the main thread have been deprecated due to the negative
 567      * effects to the user experience.
 568      */
 569     if(!V_BOOL(&varAsync)) {
 570         FIXME("Synchronous request is not supported yet\n");
 571         return E_FAIL;
 572     }
 573
 574     hres = variant_to_nsastr(varUser, &user);
 575     if(FAILED(hres))
 576         return hres;
 577     hres = variant_to_nsastr(varPassword, &password);
 578     if(FAILED(hres)) {
 579         nsAString_Finish(&user);
 580         return hres;
 581     }
 582
 583     hres = bstr_to_nsacstr(bstrMethod, &method);
 584     if(FAILED(hres)) {
 585         nsAString_Finish(&user);
 586         nsAString_Finish(&password);
 587         return hres;
 588     }
 589     hres = bstr_to_nsacstr(bstrUrl, &url);
 590     if(FAILED(hres)) {
 591         nsAString_Finish(&user);
 592         nsAString_Finish(&password);
 593         nsACString_Finish(&method);
 594         return hres;
 595     }
 596
 597     nsres = nsIXMLHttpRequest_Open(This->nsxhr, &method, &url, TRUE,
 598             &user, &password, 0);
 599
 600     nsACString_Finish(&method);
 601     nsACString_Finish(&url);
 602     nsAString_Finish(&user);
 603     nsAString_Finish(&password);
 604
 605     if(NS_FAILED(nsres)) {
 606         ERR("nsIXMLHttpRequest_Open failed: %08lx\n", nsres);
 607         return E_FAIL;
 608     }
 609
 610     return S_OK;
 611 }
 612
 613 static HRESULT WINAPI HTMLXMLHttpRequest_send(IHTMLXMLHttpRequest *iface, VARIANT varBody)
 614 {
 615     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 616     nsIWritableVariant *nsbody = NULL;
 617     nsresult nsres = NS_OK;
 618
 619     TRACE("(%p)->(%s)\n", This, debugstr_variant(&varBody));
 620
 621     switch(V_VT(&varBody)) {
 622     case VT_NULL:
 623     case VT_EMPTY:
 624     case VT_ERROR:
 625         break;
 626     case VT_BSTR: {
 627         nsAString nsstr;
 628
 629         nsbody = create_nsvariant();
 630         if(!nsbody)
 631             return E_OUTOFMEMORY;
 632
 633         nsAString_InitDepend(&nsstr, V_BSTR(&varBody));
 634         nsres = nsIWritableVariant_SetAsAString(nsbody, &nsstr);
 635         nsAString_Finish(&nsstr);
 636         break;
 637     }
 638     default:
 639         FIXME("unsupported body type %s\n", debugstr_variant(&varBody));
 640         return E_NOTIMPL;
 641     }
 642
 643     if(NS_SUCCEEDED(nsres))
 644         nsres = nsIXMLHttpRequest_Send(This->nsxhr, (nsIVariant*)nsbody);
 645     if(nsbody)
 646         nsIWritableVariant_Release(nsbody);
 647     if(NS_FAILED(nsres)) {
 648         ERR("nsIXMLHttpRequest_Send failed: %08lx\n", nsres);
 649         return E_FAIL;
 650     }
 651
 652     return S_OK;
 653 }
 654
 655 static HRESULT WINAPI HTMLXMLHttpRequest_getAllResponseHeaders(IHTMLXMLHttpRequest *iface, BSTR *p)
 656 {
 657     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 658     nsACString nscstr;
 659     nsresult nsres;
 660     HRESULT hres;
 661     LONG state;
 662
 663     TRACE("(%p)->(%p)\n", This, p);
 664
 665     if(!p)
 666         return E_POINTER;
 667
 668     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 669     if(FAILED(hres))
 670         return hres;
 671
 672     if(state < 2) {
 673         *p = NULL;
 674         return E_FAIL;
 675     }
 676
 677     nsACString_Init(&nscstr, NULL);
 678     nsres = nsIXMLHttpRequest_GetAllResponseHeaders(This->nsxhr, &nscstr);
 679     return return_nscstr(nsres, &nscstr, p);
 680 }
 681
 682 static HRESULT WINAPI HTMLXMLHttpRequest_getResponseHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR *p)
 683 {
 684     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 685     nsACString header, ret;
 686     char *cstr;
 687     nsresult nsres;
 688     HRESULT hres;
 689     LONG state;
 690     TRACE("(%p)->(%s %p)\n", This, debugstr_w(bstrHeader), p);
 691
 692     if(!p)
 693         return E_POINTER;
 694     if(!bstrHeader)
 695         return E_INVALIDARG;
 696
 697     hres = IHTMLXMLHttpRequest_get_readyState(iface, &state);
 698     if(FAILED(hres))
 699         return hres;
 700
 701     if(state < 2) {
 702         *p = NULL;
 703         return E_FAIL;
 704     }
 705
 706     cstr = strdupWtoU(bstrHeader);
 707     nsACString_InitDepend(&header, cstr);
 708     nsACString_Init(&ret, NULL);
 709
 710     nsres = nsIXMLHttpRequest_GetResponseHeader(This->nsxhr, &header, &ret);
 711
 712     nsACString_Finish(&header);
 713     free(cstr);
 714     return return_nscstr(nsres, &ret, p);
 715 }
 716
 717 static HRESULT WINAPI HTMLXMLHttpRequest_setRequestHeader(IHTMLXMLHttpRequest *iface, BSTR bstrHeader, BSTR bstrValue)
 718 {
 719     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest(iface);
 720     char *header_u, *value_u;
 721     nsACString header, value;
 722     nsresult nsres;
 723
 724     TRACE("(%p)->(%s %s)\n", This, debugstr_w(bstrHeader), debugstr_w(bstrValue));
 725
 726     header_u = strdupWtoU(bstrHeader);
 727     if(bstrHeader && !header_u)
 728         return E_OUTOFMEMORY;
 729
 730     value_u = strdupWtoU(bstrValue);
 731     if(bstrValue && !value_u) {
 732         free(header_u);
 733         return E_OUTOFMEMORY;
 734     }
 735
 736     nsACString_InitDepend(&header, header_u);
 737     nsACString_InitDepend(&value, value_u);
 738     nsres = nsIXMLHttpRequest_SetRequestHeader(This->nsxhr, &header, &value);
 739     nsACString_Finish(&header);
 740     nsACString_Finish(&value);
 741     free(header_u);
 742     free(value_u);
 743     if(NS_FAILED(nsres)) {
 744         ERR("SetRequestHeader failed: %08lx\n", nsres);
 745         return E_FAIL;
 746     }
 747
 748     return S_OK;
 749 }
 750
 751 static const IHTMLXMLHttpRequestVtbl HTMLXMLHttpRequestVtbl = {
 752     HTMLXMLHttpRequest_QueryInterface,
 753     HTMLXMLHttpRequest_AddRef,
 754     HTMLXMLHttpRequest_Release,
 755     HTMLXMLHttpRequest_GetTypeInfoCount,
 756     HTMLXMLHttpRequest_GetTypeInfo,
 757     HTMLXMLHttpRequest_GetIDsOfNames,
 758     HTMLXMLHttpRequest_Invoke,
 759     HTMLXMLHttpRequest_get_readyState,
 760     HTMLXMLHttpRequest_get_responseBody,
 761     HTMLXMLHttpRequest_get_responseText,
 762     HTMLXMLHttpRequest_get_responseXML,
 763     HTMLXMLHttpRequest_get_status,
 764     HTMLXMLHttpRequest_get_statusText,
 765     HTMLXMLHttpRequest_put_onreadystatechange,
 766     HTMLXMLHttpRequest_get_onreadystatechange,
 767     HTMLXMLHttpRequest_abort,
 768     HTMLXMLHttpRequest_open,
 769     HTMLXMLHttpRequest_send,
 770     HTMLXMLHttpRequest_getAllResponseHeaders,
 771     HTMLXMLHttpRequest_getResponseHeader,
 772     HTMLXMLHttpRequest_setRequestHeader
 773 };
 774
 775 static inline HTMLXMLHttpRequest *impl_from_IHTMLXMLHttpRequest2(IHTMLXMLHttpRequest2 *iface)
 776 {
 777     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IHTMLXMLHttpRequest2_iface);
 778 }
 779
 780 static HRESULT WINAPI HTMLXMLHttpRequest2_QueryInterface(IHTMLXMLHttpRequest2 *iface, REFIID riid, void **ppv)
 781 {
 782     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 783     return IHTMLXMLHttpRequest_QueryInterface(&This->IHTMLXMLHttpRequest_iface, riid, ppv);
 784 }
 785
 786 static ULONG WINAPI HTMLXMLHttpRequest2_AddRef(IHTMLXMLHttpRequest2 *iface)
 787 {
 788     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 789     return IHTMLXMLHttpRequest_AddRef(&This->IHTMLXMLHttpRequest_iface);
 790 }
 791
 792 static ULONG WINAPI HTMLXMLHttpRequest2_Release(IHTMLXMLHttpRequest2 *iface)
 793 {
 794     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 795     return IHTMLXMLHttpRequest_Release(&This->IHTMLXMLHttpRequest_iface);
 796 }
 797
 798 static HRESULT WINAPI HTMLXMLHttpRequest2_GetTypeInfoCount(IHTMLXMLHttpRequest2 *iface, UINT *pctinfo)
 799 {
 800     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 801     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
 802 }
 803
 804 static HRESULT WINAPI HTMLXMLHttpRequest2_GetTypeInfo(IHTMLXMLHttpRequest2 *iface, UINT iTInfo,
 805         LCID lcid, ITypeInfo **ppTInfo)
 806 {
 807     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 808     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 809 }
 810
 811 static HRESULT WINAPI HTMLXMLHttpRequest2_GetIDsOfNames(IHTMLXMLHttpRequest2 *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 812         LCID lcid, DISPID *rgDispId)
 813 {
 814     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 815     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 816             lcid, rgDispId);
 817 }
 818
 819 static HRESULT WINAPI HTMLXMLHttpRequest2_Invoke(IHTMLXMLHttpRequest2 *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 820         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 821 {
 822     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 823     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 824             pDispParams, pVarResult, pExcepInfo, puArgErr);
 825 }
 826
 827 static HRESULT WINAPI HTMLXMLHttpRequest2_put_timeout(IHTMLXMLHttpRequest2 *iface, LONG v)
 828 {
 829     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 830
 831     TRACE("(%p)->(%ld)\n", This, v);
 832
 833     if(v < 0)
 834         return E_INVALIDARG;
 835     return map_nsresult(nsIXMLHttpRequest_SetTimeout(This->nsxhr, v));
 836 }
 837
 838 static HRESULT WINAPI HTMLXMLHttpRequest2_get_timeout(IHTMLXMLHttpRequest2 *iface, LONG *p)
 839 {
 840     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 841     nsresult nsres;
 842     UINT32 timeout;
 843
 844     TRACE("(%p)->(%p)\n", This, p);
 845
 846     if(!p)
 847         return E_POINTER;
 848
 849     nsres = nsIXMLHttpRequest_GetTimeout(This->nsxhr, &timeout);
 850     *p = timeout;
 851     return map_nsresult(nsres);
 852 }
 853
 854 static HRESULT WINAPI HTMLXMLHttpRequest2_put_ontimeout(IHTMLXMLHttpRequest2 *iface, VARIANT v)
 855 {
 856     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 857
 858     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
 859
 860     return set_event_handler(&This->event_target, EVENTID_TIMEOUT, &v);
 861 }
 862
 863 static HRESULT WINAPI HTMLXMLHttpRequest2_get_ontimeout(IHTMLXMLHttpRequest2 *iface, VARIANT *p)
 864 {
 865     HTMLXMLHttpRequest *This = impl_from_IHTMLXMLHttpRequest2(iface);
 866
 867     TRACE("(%p)->(%p)\n", This, p);
 868
 869     return get_event_handler(&This->event_target, EVENTID_TIMEOUT, p);
 870 }
 871
 872 static const IHTMLXMLHttpRequest2Vtbl HTMLXMLHttpRequest2Vtbl = {
 873     HTMLXMLHttpRequest2_QueryInterface,
 874     HTMLXMLHttpRequest2_AddRef,
 875     HTMLXMLHttpRequest2_Release,
 876     HTMLXMLHttpRequest2_GetTypeInfoCount,
 877     HTMLXMLHttpRequest2_GetTypeInfo,
 878     HTMLXMLHttpRequest2_GetIDsOfNames,
 879     HTMLXMLHttpRequest2_Invoke,
 880     HTMLXMLHttpRequest2_put_timeout,
 881     HTMLXMLHttpRequest2_get_timeout,
 882     HTMLXMLHttpRequest2_put_ontimeout,
 883     HTMLXMLHttpRequest2_get_ontimeout
 884 };
 885
 886 static inline HTMLXMLHttpRequest *impl_from_IWineXMLHttpRequestPrivate(IWineXMLHttpRequestPrivate *iface)
 887 {
 888     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IWineXMLHttpRequestPrivate_iface);
 889 }
 890
 891 static HRESULT WINAPI HTMLXMLHttpRequest_private_QueryInterface(IWineXMLHttpRequestPrivate *iface, REFIID riid, void **ppv)
 892 {
 893     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 894     return IHTMLXMLHttpRequest_QueryInterface(&This->IHTMLXMLHttpRequest_iface, riid, ppv);
 895 }
 896
 897 static ULONG WINAPI HTMLXMLHttpRequest_private_AddRef(IWineXMLHttpRequestPrivate *iface)
 898 {
 899     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 900     return IHTMLXMLHttpRequest_AddRef(&This->IHTMLXMLHttpRequest_iface);
 901 }
 902
 903 static ULONG WINAPI HTMLXMLHttpRequest_private_Release(IWineXMLHttpRequestPrivate *iface)
 904 {
 905     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 906     return IHTMLXMLHttpRequest_Release(&This->IHTMLXMLHttpRequest_iface);
 907 }
 908
 909 static HRESULT WINAPI HTMLXMLHttpRequest_private_GetTypeInfoCount(IWineXMLHttpRequestPrivate *iface, UINT *pctinfo)
 910 {
 911     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 912     return IDispatchEx_GetTypeInfoCount(&This->event_target.dispex.IDispatchEx_iface, pctinfo);
 913 }
 914
 915 static HRESULT WINAPI HTMLXMLHttpRequest_private_GetTypeInfo(IWineXMLHttpRequestPrivate *iface, UINT iTInfo,
 916         LCID lcid, ITypeInfo **ppTInfo)
 917 {
 918     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 919     return IDispatchEx_GetTypeInfo(&This->event_target.dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 920 }
 921
 922 static HRESULT WINAPI HTMLXMLHttpRequest_private_GetIDsOfNames(IWineXMLHttpRequestPrivate *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 923         LCID lcid, DISPID *rgDispId)
 924 {
 925     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 926     return IDispatchEx_GetIDsOfNames(&This->event_target.dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 927             lcid, rgDispId);
 928 }
 929
 930 static HRESULT WINAPI HTMLXMLHttpRequest_private_Invoke(IWineXMLHttpRequestPrivate *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 931         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 932 {
 933     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 934     return IDispatchEx_Invoke(&This->event_target.dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 935             pDispParams, pVarResult, pExcepInfo, puArgErr);
 936 }
 937
 938 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_response(IWineXMLHttpRequestPrivate *iface, VARIANT *p)
 939 {
 940     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 941     HRESULT hres = S_OK;
 942     nsresult nsres;
 943     UINT16 state;
 944
 945     TRACE("(%p)->(%p)\n", This, p);
 946
 947     switch(This->response_type) {
 948     case response_type_empty:
 949     case response_type_text:
 950         hres = IHTMLXMLHttpRequest_get_responseText(&This->IHTMLXMLHttpRequest_iface, &V_BSTR(p));
 951         if(SUCCEEDED(hres))
 952             V_VT(p) = VT_BSTR;
 953         break;
 954
 955     case response_type_doc:
 956         FIXME("response_type_doc\n");
 957         return E_NOTIMPL;
 958
 959     case response_type_arraybuf:
 960     case response_type_blob:
 961         nsres = nsIXMLHttpRequest_GetReadyState(This->nsxhr, &state);
 962         if(NS_FAILED(nsres) || state < 4) {
 963             V_VT(p) = VT_EMPTY;
 964             break;
 965         }
 966         if(This->response_type == response_type_arraybuf) {
 967             FIXME("response_type_arraybuf\n");
 968             return E_NOTIMPL;
 969         }
 970         FIXME("response_type_blob\n");
 971         return E_NOTIMPL;
 972
 973     case response_type_stream:
 974         FIXME("response_type_stream\n");
 975         return E_NOTIMPL;
 976
 977     default:
 978         assert(0);
 979     }
 980
 981     return hres;
 982 }
 983
 984 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_responseType(IWineXMLHttpRequestPrivate *iface, BSTR v)
 985 {
 986     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
 987     nsAString nsstr;
 988     nsresult nsres;
 989     HRESULT hres;
 990     unsigned i;
 991     LONG state;
 992
 993     TRACE("(%p)->(%s)\n", This, debugstr_w(v));
 994
 995     hres = IHTMLXMLHttpRequest_get_readyState(&This->IHTMLXMLHttpRequest_iface, &state);
 996     if(FAILED(hres))
 997         return hres;
 998
 999     if(state < 1 || state > 2) {
1000         /* FIXME: Return InvalidStateError */
1001         return E_FAIL;
1002     }
1003
1004     for(i = 0; i < ARRAY_SIZE(response_type_desc); i++)
1005         if(!wcscmp(v, response_type_desc[i].str))
1006             break;
1007     if(i >= ARRAY_SIZE(response_type_desc))
1008         return S_OK;
1009
1010     nsAString_InitDepend(&nsstr, response_type_desc[i].nsxhr_str);
1011     nsres = nsIXMLHttpRequest_SetResponseType(This->nsxhr, &nsstr);
1012     nsAString_Finish(&nsstr);
1013     if(NS_FAILED(nsres))
1014         return map_nsresult(nsres);
1015
1016     This->response_type = i;
1017     return S_OK;
1018 }
1019
1020 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_responseType(IWineXMLHttpRequestPrivate *iface, BSTR *p)
1021 {
1022     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1023
1024     TRACE("(%p)->(%p)\n", This, p);
1025
1026     *p = SysAllocString(response_type_desc[This->response_type].str);
1027     return *p ? S_OK : E_OUTOFMEMORY;
1028 }
1029
1030 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_upload(IWineXMLHttpRequestPrivate *iface, IDispatch **p)
1031 {
1032     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1033
1034     FIXME("(%p)->(%p)\n", This, p);
1035
1036     return E_NOTIMPL;
1037 }
1038
1039 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_withCredentials(IWineXMLHttpRequestPrivate *iface, VARIANT_BOOL v)
1040 {
1041     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1042
1043     TRACE("(%p)->(%x)\n", This, v);
1044
1045     return map_nsresult(nsIXMLHttpRequest_SetWithCredentials(This->nsxhr, !!v));
1046 }
1047
1048 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_withCredentials(IWineXMLHttpRequestPrivate *iface, VARIANT_BOOL *p)
1049 {
1050     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1051     nsresult nsres;
1052     cpp_bool b;
1053
1054     TRACE("(%p)->(%p)\n", This, p);
1055
1056     nsres = nsIXMLHttpRequest_GetWithCredentials(This->nsxhr, &b);
1057     if(NS_FAILED(nsres))
1058         return map_nsresult(nsres);
1059     *p = b ? VARIANT_TRUE : VARIANT_FALSE;
1060     return S_OK;
1061 }
1062
1063 static HRESULT WINAPI HTMLXMLHttpRequest_private_overrideMimeType(IWineXMLHttpRequestPrivate *iface, BSTR mimeType)
1064 {
1065     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1066     static const WCHAR generic_type[] = L"application/octet-stream";
1067     const WCHAR *type = NULL;
1068     WCHAR *lowercase = NULL;
1069     nsAString nsstr;
1070     nsresult nsres;
1071
1072     TRACE("(%p)->(%s)\n", This, debugstr_w(mimeType));
1073
1074     if(mimeType) {
1075         if(mimeType[0]) {
1076             if(!(lowercase = wcsdup(mimeType)))
1077                 return E_OUTOFMEMORY;
1078             _wcslwr(lowercase);
1079             type = lowercase;
1080         }else
1081             type = generic_type;
1082     }
1083
1084     nsAString_InitDepend(&nsstr, type);
1085     nsres = nsIXMLHttpRequest_SlowOverrideMimeType(This->nsxhr, &nsstr);
1086     nsAString_Finish(&nsstr);
1087     free(lowercase);
1088     return map_nsresult(nsres);
1089 }
1090
1091 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_onerror(IWineXMLHttpRequestPrivate *iface, VARIANT v)
1092 {
1093     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1094
1095     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1096
1097     return set_event_handler(&This->event_target, EVENTID_ERROR, &v);
1098 }
1099
1100 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_onerror(IWineXMLHttpRequestPrivate *iface, VARIANT *p)
1101 {
1102     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1103
1104     TRACE("(%p)->(%p)\n", This, p);
1105
1106     return get_event_handler(&This->event_target, EVENTID_ERROR, p);
1107 }
1108
1109 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_onabort(IWineXMLHttpRequestPrivate *iface, VARIANT v)
1110 {
1111     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1112
1113     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1114
1115     return set_event_handler(&This->event_target, EVENTID_ABORT, &v);
1116 }
1117
1118 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_onabort(IWineXMLHttpRequestPrivate *iface, VARIANT *p)
1119 {
1120     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1121
1122     TRACE("(%p)->(%p)\n", This, p);
1123
1124     return get_event_handler(&This->event_target, EVENTID_ABORT, p);
1125 }
1126
1127 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_onprogress(IWineXMLHttpRequestPrivate *iface, VARIANT v)
1128 {
1129     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1130
1131     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1132
1133     return set_event_handler(&This->event_target, EVENTID_PROGRESS, &v);
1134 }
1135
1136 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_onprogress(IWineXMLHttpRequestPrivate *iface, VARIANT *p)
1137 {
1138     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1139
1140     TRACE("(%p)->(%p)\n", This, p);
1141
1142     return get_event_handler(&This->event_target, EVENTID_PROGRESS, p);
1143 }
1144
1145 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_onloadstart(IWineXMLHttpRequestPrivate *iface, VARIANT v)
1146 {
1147     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1148
1149     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1150
1151     return set_event_handler(&This->event_target, EVENTID_LOADSTART, &v);
1152 }
1153
1154 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_onloadstart(IWineXMLHttpRequestPrivate *iface, VARIANT *p)
1155 {
1156     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1157
1158     TRACE("(%p)->(%p)\n", This, p);
1159
1160     return get_event_handler(&This->event_target, EVENTID_LOADSTART, p);
1161 }
1162
1163 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_onloadend(IWineXMLHttpRequestPrivate *iface, VARIANT v)
1164 {
1165     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1166
1167     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1168
1169     return set_event_handler(&This->event_target, EVENTID_LOADEND, &v);
1170 }
1171
1172 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_onloadend(IWineXMLHttpRequestPrivate *iface, VARIANT *p)
1173 {
1174     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1175
1176     TRACE("(%p)->(%p)\n", This, p);
1177
1178     return get_event_handler(&This->event_target, EVENTID_LOADEND, p);
1179 }
1180
1181 static HRESULT WINAPI HTMLXMLHttpRequest_private_put_onload(IWineXMLHttpRequestPrivate *iface, VARIANT v)
1182 {
1183     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1184
1185     TRACE("(%p)->(%s)\n", This, debugstr_variant(&v));
1186
1187     return set_event_handler(&This->event_target, EVENTID_LOAD, &v);
1188 }
1189
1190 static HRESULT WINAPI HTMLXMLHttpRequest_private_get_onload(IWineXMLHttpRequestPrivate *iface, VARIANT *p)
1191 {
1192     HTMLXMLHttpRequest *This = impl_from_IWineXMLHttpRequestPrivate(iface);
1193
1194     TRACE("(%p)->(%p)\n", This, p);
1195
1196     return get_event_handler(&This->event_target, EVENTID_LOAD, p);
1197 }
1198
1199 static const IWineXMLHttpRequestPrivateVtbl WineXMLHttpRequestPrivateVtbl = {
1200     HTMLXMLHttpRequest_private_QueryInterface,
1201     HTMLXMLHttpRequest_private_AddRef,
1202     HTMLXMLHttpRequest_private_Release,
1203     HTMLXMLHttpRequest_private_GetTypeInfoCount,
1204     HTMLXMLHttpRequest_private_GetTypeInfo,
1205     HTMLXMLHttpRequest_private_GetIDsOfNames,
1206     HTMLXMLHttpRequest_private_Invoke,
1207     HTMLXMLHttpRequest_private_get_response,
1208     HTMLXMLHttpRequest_private_put_responseType,
1209     HTMLXMLHttpRequest_private_get_responseType,
1210     HTMLXMLHttpRequest_private_get_upload,
1211     HTMLXMLHttpRequest_private_put_withCredentials,
1212     HTMLXMLHttpRequest_private_get_withCredentials,
1213     HTMLXMLHttpRequest_private_overrideMimeType,
1214     HTMLXMLHttpRequest_private_put_onerror,
1215     HTMLXMLHttpRequest_private_get_onerror,
1216     HTMLXMLHttpRequest_private_put_onabort,
1217     HTMLXMLHttpRequest_private_get_onabort,
1218     HTMLXMLHttpRequest_private_put_onprogress,
1219     HTMLXMLHttpRequest_private_get_onprogress,
1220     HTMLXMLHttpRequest_private_put_onloadstart,
1221     HTMLXMLHttpRequest_private_get_onloadstart,
1222     HTMLXMLHttpRequest_private_put_onloadend,
1223     HTMLXMLHttpRequest_private_get_onloadend,
1224     HTMLXMLHttpRequest_private_put_onload,
1225     HTMLXMLHttpRequest_private_get_onload
1226 };
1227
1228 static inline HTMLXMLHttpRequest *impl_from_IProvideClassInfo2(IProvideClassInfo2 *iface)
1229 {
1230     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, IProvideClassInfo2_iface);
1231 }
1232
1233 static HRESULT WINAPI ProvideClassInfo_QueryInterface(IProvideClassInfo2 *iface, REFIID riid, void **ppv)
1234 {
1235     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
1236     return IHTMLXMLHttpRequest_QueryInterface(&This->IHTMLXMLHttpRequest_iface, riid, ppv);
1237 }
1238
1239 static ULONG WINAPI ProvideClassInfo_AddRef(IProvideClassInfo2 *iface)
1240 {
1241     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
1242     return IHTMLXMLHttpRequest_AddRef(&This->IHTMLXMLHttpRequest_iface);
1243 }
1244
1245 static ULONG WINAPI ProvideClassInfo_Release(IProvideClassInfo2 *iface)
1246 {
1247     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
1248     return IHTMLXMLHttpRequest_Release(&This->IHTMLXMLHttpRequest_iface);
1249 }
1250
1251 static HRESULT WINAPI ProvideClassInfo_GetClassInfo(IProvideClassInfo2 *iface, ITypeInfo **ppTI)
1252 {
1253     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
1254     TRACE("(%p)->(%p)\n", This, ppTI);
1255     return get_class_typeinfo(&CLSID_HTMLXMLHttpRequest, ppTI);
1256 }
1257
1258 static HRESULT WINAPI ProvideClassInfo2_GetGUID(IProvideClassInfo2 *iface, DWORD dwGuidKind, GUID *pGUID)
1259 {
1260     HTMLXMLHttpRequest *This = impl_from_IProvideClassInfo2(iface);
1261     FIXME("(%p)->(%lu %p)\n", This, dwGuidKind, pGUID);
1262     return E_NOTIMPL;
1263 }
1264
1265 static const IProvideClassInfo2Vtbl ProvideClassInfo2Vtbl = {
1266     ProvideClassInfo_QueryInterface,
1267     ProvideClassInfo_AddRef,
1268     ProvideClassInfo_Release,
1269     ProvideClassInfo_GetClassInfo,
1270     ProvideClassInfo2_GetGUID,
1271 };
1272
1273 static inline HTMLXMLHttpRequest *impl_from_DispatchEx(DispatchEx *iface)
1274 {
1275     return CONTAINING_RECORD(iface, HTMLXMLHttpRequest, event_target.dispex);
1276 }
1277
1278 static nsISupports *HTMLXMLHttpRequest_get_gecko_target(DispatchEx *dispex)
1279 {
1280     HTMLXMLHttpRequest *This = impl_from_DispatchEx(dispex);
1281     return (nsISupports*)This->nsxhr;
1282 }
1283
1284 static void HTMLXMLHttpRequest_bind_event(DispatchEx *dispex, eventid_t eid)
1285 {
1286     HTMLXMLHttpRequest *This = impl_from_DispatchEx(dispex);
1287     nsIDOMEventTarget *nstarget;
1288     nsAString type_str;
1289     const WCHAR *name;
1290     nsresult nsres;
1291     unsigned i;
1292
1293     TRACE("(%p)\n", This);
1294
1295     for(i = 0; i < ARRAY_SIZE(events); i++)
1296         if(eid == events[i])
1297             break;
1298     if(i >= ARRAY_SIZE(events))
1299         return;
1300
1301     if(!This->event_listener) {
1302         This->event_listener = malloc(sizeof(*This->event_listener));
1303         if(!This->event_listener)
1304             return;
1305
1306         This->event_listener->nsIDOMEventListener_iface.lpVtbl = &XMLHttpReqEventListenerVtbl;
1307         This->event_listener->ref = 1;
1308         This->event_listener->xhr = This;
1309         This->event_listener->events_mask = 0;
1310     }
1311
1312     nsres = nsIXMLHttpRequest_QueryInterface(This->nsxhr, &IID_nsIDOMEventTarget, (void**)&nstarget);
1313     assert(nsres == NS_OK);
1314
1315     name = get_event_name(events[i]);
1316     nsAString_InitDepend(&type_str, name);
1317     nsres = nsIDOMEventTarget_AddEventListener(nstarget, &type_str, &This->event_listener->nsIDOMEventListener_iface, FALSE, TRUE, 2);
1318     nsAString_Finish(&type_str);
1319     if(NS_FAILED(nsres))
1320         ERR("AddEventListener(%s) failed: %08lx\n", debugstr_w(name), nsres);
1321
1322     nsIDOMEventTarget_Release(nstarget);
1323
1324     This->event_listener->events_mask |= 1 << i;
1325 }
1326
1327 static void HTMLXMLHttpRequest_init_dispex_info(dispex_data_t *info, compat_mode_t compat_mode)
1328 {
1329     static const dispex_hook_t xhr_hooks[] = {
1330         {DISPID_IHTMLXMLHTTPREQUEST_OPEN, HTMLXMLHttpRequest_open_hook},
1331         {DISPID_UNKNOWN}
1332     };
1333     static const dispex_hook_t private_hooks[] = {
1334         {DISPID_IWINEXMLHTTPREQUESTPRIVATE_RESPONSE},
1335         {DISPID_IWINEXMLHTTPREQUESTPRIVATE_RESPONSETYPE},
1336         {DISPID_IWINEXMLHTTPREQUESTPRIVATE_UPLOAD},
1337         {DISPID_IWINEXMLHTTPREQUESTPRIVATE_WITHCREDENTIALS},
1338         {DISPID_EVPROP_ONERROR},
1339         {DISPID_EVPROP_ONABORT},
1340         {DISPID_EVPROP_PROGRESS},
1341         {DISPID_EVPROP_LOADSTART},
1342         {DISPID_EVPROP_LOADEND},
1343
1344         /* IE10 only */
1345         {DISPID_IWINEXMLHTTPREQUESTPRIVATE_OVERRIDEMIMETYPE},
1346         {DISPID_UNKNOWN}
1347     };
1348     const dispex_hook_t *const private_ie10_hooks = private_hooks + ARRAY_SIZE(private_hooks) - 2;
1349
1350     EventTarget_init_dispex_info(info, compat_mode);
1351     dispex_info_add_interface(info, IHTMLXMLHttpRequest_tid, compat_mode >= COMPAT_MODE_IE10 ? xhr_hooks : NULL);
1352     dispex_info_add_interface(info, IWineXMLHttpRequestPrivate_tid,
1353         compat_mode < COMPAT_MODE_IE10 ? private_hooks :
1354         compat_mode < COMPAT_MODE_IE11 ? private_ie10_hooks : NULL);
1355 }
1356
1357 static event_target_vtbl_t HTMLXMLHttpRequest_event_target_vtbl = {
1358     {
1359         NULL,
1360     },
1361     HTMLXMLHttpRequest_get_gecko_target,
1362     HTMLXMLHttpRequest_bind_event
1363 };
1364
1365 static const tid_t HTMLXMLHttpRequest_iface_tids[] = {
1366     IHTMLXMLHttpRequest2_tid,
1367     0
1368 };
1369 static dispex_static_data_t HTMLXMLHttpRequest_dispex = {
1370     L"XMLHttpRequest",
1371     &HTMLXMLHttpRequest_event_target_vtbl.dispex_vtbl,
1372     DispHTMLXMLHttpRequest_tid,
1373     HTMLXMLHttpRequest_iface_tids,
1374     HTMLXMLHttpRequest_init_dispex_info
1375 };
1376
1377
1378 /* IHTMLXMLHttpRequestFactory */
1379 static inline HTMLXMLHttpRequestFactory *impl_from_IHTMLXMLHttpRequestFactory(IHTMLXMLHttpRequestFactory *iface)
1380 {
1381     return CONTAINING_RECORD(iface, HTMLXMLHttpRequestFactory, IHTMLXMLHttpRequestFactory_iface);
1382 }
1383
1384 static HRESULT WINAPI HTMLXMLHttpRequestFactory_QueryInterface(IHTMLXMLHttpRequestFactory *iface, REFIID riid, void **ppv)
1385 {
1386     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1387
1388     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1389
1390     if(IsEqualGUID(&IID_IUnknown, riid)) {
1391         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
1392     }else if(IsEqualGUID(&IID_IDispatch, riid)) {
1393         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
1394     }else if(IsEqualGUID(&IID_IHTMLXMLHttpRequestFactory, riid)) {
1395         *ppv = &This->IHTMLXMLHttpRequestFactory_iface;
1396     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1397         return *ppv ? S_OK : E_NOINTERFACE;
1398     }else {
1399         *ppv = NULL;
1400         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1401         return E_NOINTERFACE;
1402     }
1403
1404     IUnknown_AddRef((IUnknown*)*ppv);
1405     return S_OK;
1406 }
1407
1408 static ULONG WINAPI HTMLXMLHttpRequestFactory_AddRef(IHTMLXMLHttpRequestFactory *iface)
1409 {
1410     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1411     LONG ref = InterlockedIncrement(&This->ref);
1412
1413     TRACE("(%p) ref=%ld\n", This, ref);
1414
1415     return ref;
1416 }
1417
1418 static ULONG WINAPI HTMLXMLHttpRequestFactory_Release(IHTMLXMLHttpRequestFactory *iface)
1419 {
1420     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1421     LONG ref = InterlockedDecrement(&This->ref);
1422
1423     TRACE("(%p) ref=%ld\n", This, ref);
1424
1425     if(!ref) {
1426         release_dispex(&This->dispex);
1427         free(This);
1428     }
1429
1430     return ref;
1431 }
1432
1433 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetTypeInfoCount(IHTMLXMLHttpRequestFactory *iface, UINT *pctinfo)
1434 {
1435     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1436     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
1437 }
1438
1439 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetTypeInfo(IHTMLXMLHttpRequestFactory *iface, UINT iTInfo,
1440         LCID lcid, ITypeInfo **ppTInfo)
1441 {
1442     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1443
1444     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1445 }
1446
1447 static HRESULT WINAPI HTMLXMLHttpRequestFactory_GetIDsOfNames(IHTMLXMLHttpRequestFactory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
1448         LCID lcid, DISPID *rgDispId)
1449 {
1450     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1451
1452     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1453             lcid, rgDispId);
1454 }
1455
1456 static HRESULT WINAPI HTMLXMLHttpRequestFactory_Invoke(IHTMLXMLHttpRequestFactory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
1457         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1458 {
1459     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1460
1461     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1462             pDispParams, pVarResult, pExcepInfo, puArgErr);
1463 }
1464
1465 static HRESULT WINAPI HTMLXMLHttpRequestFactory_create(IHTMLXMLHttpRequestFactory *iface, IHTMLXMLHttpRequest **p)
1466 {
1467     HTMLXMLHttpRequestFactory *This = impl_from_IHTMLXMLHttpRequestFactory(iface);
1468     HTMLXMLHttpRequest        *ret;
1469     nsIXMLHttpRequest         *nsxhr;
1470
1471     TRACE("(%p)->(%p)\n", This, p);
1472
1473     nsxhr = create_nsxhr(This->window->base.outer_window->nswindow);
1474     if(!nsxhr)
1475         return E_FAIL;
1476
1477     ret = calloc(1, sizeof(*ret));
1478     if(!ret) {
1479         nsIXMLHttpRequest_Release(nsxhr);
1480         return E_OUTOFMEMORY;
1481     }
1482     ret->nsxhr = nsxhr;
1483
1484     ret->IHTMLXMLHttpRequest_iface.lpVtbl = &HTMLXMLHttpRequestVtbl;
1485     ret->IHTMLXMLHttpRequest2_iface.lpVtbl = &HTMLXMLHttpRequest2Vtbl;
1486     ret->IWineXMLHttpRequestPrivate_iface.lpVtbl = &WineXMLHttpRequestPrivateVtbl;
1487     ret->IProvideClassInfo2_iface.lpVtbl = &ProvideClassInfo2Vtbl;
1488     EventTarget_Init(&ret->event_target, (IUnknown*)&ret->IHTMLXMLHttpRequest_iface,
1489                      &HTMLXMLHttpRequest_dispex, This->window->doc->document_mode);
1490     ret->ref = 1;
1491
1492     *p = &ret->IHTMLXMLHttpRequest_iface;
1493     return S_OK;
1494 }
1495
1496 static const IHTMLXMLHttpRequestFactoryVtbl HTMLXMLHttpRequestFactoryVtbl = {
1497     HTMLXMLHttpRequestFactory_QueryInterface,
1498     HTMLXMLHttpRequestFactory_AddRef,
1499     HTMLXMLHttpRequestFactory_Release,
1500     HTMLXMLHttpRequestFactory_GetTypeInfoCount,
1501     HTMLXMLHttpRequestFactory_GetTypeInfo,
1502     HTMLXMLHttpRequestFactory_GetIDsOfNames,
1503     HTMLXMLHttpRequestFactory_Invoke,
1504     HTMLXMLHttpRequestFactory_create
1505 };
1506
1507 static inline HTMLXMLHttpRequestFactory *factory_from_DispatchEx(DispatchEx *iface)
1508 {
1509     return CONTAINING_RECORD(iface, HTMLXMLHttpRequestFactory, dispex);
1510 }
1511
1512 static HRESULT HTMLXMLHttpRequestFactory_value(DispatchEx *iface, LCID lcid, WORD flags, DISPPARAMS *params,
1513         VARIANT *res, EXCEPINFO *ei, IServiceProvider *caller)
1514 {
1515     HTMLXMLHttpRequestFactory *This = factory_from_DispatchEx(iface);
1516     IHTMLXMLHttpRequest *xhr;
1517     HRESULT hres;
1518
1519     TRACE("\n");
1520
1521     if(flags != DISPATCH_CONSTRUCT) {
1522         FIXME("flags %x not supported\n", flags);
1523         return E_NOTIMPL;
1524     }
1525
1526     hres = IHTMLXMLHttpRequestFactory_create(&This->IHTMLXMLHttpRequestFactory_iface, &xhr);
1527     if(FAILED(hres))
1528         return hres;
1529
1530     V_VT(res) = VT_DISPATCH;
1531     V_DISPATCH(res) = (IDispatch*)xhr;
1532     return S_OK;
1533 }
1534
1535 static const dispex_static_data_vtbl_t HTMLXMLHttpRequestFactory_dispex_vtbl = {
1536     HTMLXMLHttpRequestFactory_value
1537 };
1538
1539 static const tid_t HTMLXMLHttpRequestFactory_iface_tids[] = {
1540     IHTMLXMLHttpRequestFactory_tid,
1541     0
1542 };
1543 static dispex_static_data_t HTMLXMLHttpRequestFactory_dispex = {
1544     L"Function",
1545     &HTMLXMLHttpRequestFactory_dispex_vtbl,
1546     IHTMLXMLHttpRequestFactory_tid,
1547     HTMLXMLHttpRequestFactory_iface_tids
1548 };
1549
1550 HRESULT HTMLXMLHttpRequestFactory_Create(HTMLInnerWindow* window, HTMLXMLHttpRequestFactory **ret_ptr)
1551 {
1552     HTMLXMLHttpRequestFactory *ret;
1553
1554     ret = malloc(sizeof(*ret));
1555     if(!ret)
1556         return E_OUTOFMEMORY;
1557
1558     ret->IHTMLXMLHttpRequestFactory_iface.lpVtbl = &HTMLXMLHttpRequestFactoryVtbl;
1559     ret->ref = 1;
1560     ret->window = window;
1561
1562     init_dispatch(&ret->dispex, (IUnknown*)&ret->IHTMLXMLHttpRequestFactory_iface,
1563                   &HTMLXMLHttpRequestFactory_dispex, dispex_compat_mode(&window->event_target.dispex));
1564
1565     *ret_ptr = ret;
1566     return S_OK;
1567 }