dlls/mshtml/omnavigator.c

   1 /*
   2  * Copyright 2008,2009 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #define COBJMACROS
  22
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winuser.h"
  26 #include "ole2.h"
  27
  28 #include "wine/debug.h"
  29
  30 #include "mshtml_private.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
  33
  34 typedef struct HTMLPluginsCollection HTMLPluginsCollection;
  35 typedef struct HTMLMimeTypesCollection HTMLMimeTypesCollection;
  36
  37 typedef struct {
  38     DispatchEx dispex;
  39     IOmNavigator IOmNavigator_iface;
  40
  41     LONG ref;
  42
  43     HTMLPluginsCollection *plugins;
  44     HTMLMimeTypesCollection *mime_types;
  45 } OmNavigator;
  46
  47 typedef struct {
  48     DispatchEx dispex;
  49     IHTMLDOMImplementation IHTMLDOMImplementation_iface;
  50     IHTMLDOMImplementation2 IHTMLDOMImplementation2_iface;
  51
  52     LONG ref;
  53
  54     nsIDOMDOMImplementation *implementation;
  55     GeckoBrowser *browser;
  56 } HTMLDOMImplementation;
  57
  58 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation(IHTMLDOMImplementation *iface)
  59 {
  60     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation_iface);
  61 }
  62
  63 static HRESULT WINAPI HTMLDOMImplementation_QueryInterface(IHTMLDOMImplementation *iface, REFIID riid, void **ppv)
  64 {
  65     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  66
  67     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
  68
  69     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IHTMLDOMImplementation, riid)) {
  70         *ppv = &This->IHTMLDOMImplementation_iface;
  71     }else if(IsEqualGUID(&IID_IHTMLDOMImplementation2, riid)) {
  72         *ppv = &This->IHTMLDOMImplementation2_iface;
  73     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
  74         return *ppv ? S_OK : E_NOINTERFACE;
  75     }else {
  76         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
  77         *ppv = NULL;
  78         return E_NOINTERFACE;
  79     }
  80
  81     IUnknown_AddRef((IUnknown*)*ppv);
  82     return S_OK;
  83 }
  84
  85 static ULONG WINAPI HTMLDOMImplementation_AddRef(IHTMLDOMImplementation *iface)
  86 {
  87     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  88     LONG ref = InterlockedIncrement(&This->ref);
  89
  90     TRACE("(%p) ref=%ld\n", This, ref);
  91
  92     return ref;
  93 }
  94
  95 static ULONG WINAPI HTMLDOMImplementation_Release(IHTMLDOMImplementation *iface)
  96 {
  97     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  98     LONG ref = InterlockedDecrement(&This->ref);
  99
 100     TRACE("(%p) ref=%ld\n", This, ref);
 101
 102     if(!ref) {
 103         assert(!This->browser);
 104         if(This->implementation)
 105             nsIDOMDOMImplementation_Release(This->implementation);
 106         release_dispex(&This->dispex);
 107         free(This);
 108     }
 109
 110     return ref;
 111 }
 112
 113 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfoCount(IHTMLDOMImplementation *iface, UINT *pctinfo)
 114 {
 115     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 116
 117     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 118 }
 119
 120 static HRESULT WINAPI HTMLDOMImplementation_GetTypeInfo(IHTMLDOMImplementation *iface, UINT iTInfo,
 121         LCID lcid, ITypeInfo **ppTInfo)
 122 {
 123     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 124
 125     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 126 }
 127
 128 static HRESULT WINAPI HTMLDOMImplementation_GetIDsOfNames(IHTMLDOMImplementation *iface, REFIID riid,
 129         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 130 {
 131     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 132
 133     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 134             cNames, lcid, rgDispId);
 135 }
 136
 137 static HRESULT WINAPI HTMLDOMImplementation_Invoke(IHTMLDOMImplementation *iface, DISPID dispIdMember,
 138         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 139         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 140 {
 141     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 142
 143     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 144             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 145 }
 146
 147 static HRESULT WINAPI HTMLDOMImplementation_hasFeature(IHTMLDOMImplementation *iface, BSTR feature,
 148         VARIANT version, VARIANT_BOOL *pfHasFeature)
 149 {
 150     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
 151
 152     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 153
 154     *pfHasFeature = VARIANT_FALSE;
 155     return S_OK;
 156 }
 157
 158 static const IHTMLDOMImplementationVtbl HTMLDOMImplementationVtbl = {
 159     HTMLDOMImplementation_QueryInterface,
 160     HTMLDOMImplementation_AddRef,
 161     HTMLDOMImplementation_Release,
 162     HTMLDOMImplementation_GetTypeInfoCount,
 163     HTMLDOMImplementation_GetTypeInfo,
 164     HTMLDOMImplementation_GetIDsOfNames,
 165     HTMLDOMImplementation_Invoke,
 166     HTMLDOMImplementation_hasFeature
 167 };
 168
 169 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation2(IHTMLDOMImplementation2 *iface)
 170 {
 171     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation2_iface);
 172 }
 173
 174 static HRESULT WINAPI HTMLDOMImplementation2_QueryInterface(IHTMLDOMImplementation2 *iface, REFIID riid, void **ppv)
 175 {
 176     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 177     return IHTMLDOMImplementation_QueryInterface(&This->IHTMLDOMImplementation_iface, riid, ppv);
 178 }
 179
 180 static ULONG WINAPI HTMLDOMImplementation2_AddRef(IHTMLDOMImplementation2 *iface)
 181 {
 182     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 183     return IHTMLDOMImplementation_AddRef(&This->IHTMLDOMImplementation_iface);
 184 }
 185
 186 static ULONG WINAPI HTMLDOMImplementation2_Release(IHTMLDOMImplementation2 *iface)
 187 {
 188     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 189     return IHTMLDOMImplementation_Release(&This->IHTMLDOMImplementation_iface);
 190 }
 191
 192 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfoCount(IHTMLDOMImplementation2 *iface, UINT *pctinfo)
 193 {
 194     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 195     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 196 }
 197
 198 static HRESULT WINAPI HTMLDOMImplementation2_GetTypeInfo(IHTMLDOMImplementation2 *iface, UINT iTInfo,
 199         LCID lcid, ITypeInfo **ppTInfo)
 200 {
 201     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 202     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 203 }
 204
 205 static HRESULT WINAPI HTMLDOMImplementation2_GetIDsOfNames(IHTMLDOMImplementation2 *iface, REFIID riid,
 206         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 207 {
 208     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 209     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames,
 210             cNames, lcid, rgDispId);
 211 }
 212
 213 static HRESULT WINAPI HTMLDOMImplementation2_Invoke(IHTMLDOMImplementation2 *iface, DISPID dispIdMember,
 214         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 215         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 216 {
 217     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 218     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid,
 219             lcid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 220 }
 221
 222 static HRESULT WINAPI HTMLDOMImplementation2_createDocumentType(IHTMLDOMImplementation2 *iface, BSTR name,
 223         VARIANT *public_id, VARIANT *system_id, IDOMDocumentType **new_type)
 224 {
 225     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 226     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(name), debugstr_variant(public_id),
 227           debugstr_variant(system_id), new_type);
 228     return E_NOTIMPL;
 229 }
 230
 231 static HRESULT WINAPI HTMLDOMImplementation2_createDocument(IHTMLDOMImplementation2 *iface, VARIANT *ns,
 232         VARIANT *tag_name, IDOMDocumentType *document_type, IHTMLDocument7 **new_document)
 233 {
 234     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 235     FIXME("(%p)->(%s %s %p %p)\n", This, debugstr_variant(ns), debugstr_variant(tag_name),
 236           document_type, new_document);
 237     return E_NOTIMPL;
 238 }
 239
 240 static HRESULT WINAPI HTMLDOMImplementation2_createHTMLDocument(IHTMLDOMImplementation2 *iface, BSTR title,
 241         IHTMLDocument7 **new_document)
 242 {
 243     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 244     HTMLDocumentNode *new_document_node;
 245     nsIDOMDocument *doc;
 246     nsAString title_str;
 247     nsresult nsres;
 248     HRESULT hres;
 249
 250     FIXME("(%p)->(%s %p)\n", This, debugstr_w(title), new_document);
 251
 252     if(!This->browser)
 253         return E_UNEXPECTED;
 254
 255     nsAString_InitDepend(&title_str, title);
 256     nsres = nsIDOMDOMImplementation_CreateHTMLDocument(This->implementation, &title_str, &doc);
 257     nsAString_Finish(&title_str);
 258     if(NS_FAILED(nsres)) {
 259         ERR("CreateHTMLDocument failed: %08lx\n", nsres);
 260         return E_FAIL;
 261     }
 262
 263     hres = create_document_node(doc, This->browser, NULL, dispex_compat_mode(&This->dispex), &new_document_node);
 264     nsIDOMDocument_Release(doc);
 265     if(FAILED(hres))
 266         return hres;
 267
 268     *new_document = &new_document_node->IHTMLDocument7_iface;
 269     return S_OK;
 270 }
 271
 272 static HRESULT WINAPI HTMLDOMImplementation2_hasFeature(IHTMLDOMImplementation2 *iface, BSTR feature,
 273         VARIANT version, VARIANT_BOOL *pfHasFeature)
 274 {
 275     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 276
 277     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 278
 279     *pfHasFeature = VARIANT_FALSE;
 280     return S_OK;
 281 }
 282
 283 static const IHTMLDOMImplementation2Vtbl HTMLDOMImplementation2Vtbl = {
 284     HTMLDOMImplementation2_QueryInterface,
 285     HTMLDOMImplementation2_AddRef,
 286     HTMLDOMImplementation2_Release,
 287     HTMLDOMImplementation2_GetTypeInfoCount,
 288     HTMLDOMImplementation2_GetTypeInfo,
 289     HTMLDOMImplementation2_GetIDsOfNames,
 290     HTMLDOMImplementation2_Invoke,
 291     HTMLDOMImplementation2_createDocumentType,
 292     HTMLDOMImplementation2_createDocument,
 293     HTMLDOMImplementation2_createHTMLDocument,
 294     HTMLDOMImplementation2_hasFeature
 295 };
 296
 297 static void HTMLDOMImplementation_init_dispex_info(dispex_data_t *info, compat_mode_t compat_mode)
 298 {
 299     if(compat_mode >= COMPAT_MODE_IE9)
 300         dispex_info_add_interface(info, IHTMLDOMImplementation2_tid, NULL);
 301 }
 302
 303 static const tid_t HTMLDOMImplementation_iface_tids[] = {
 304     IHTMLDOMImplementation_tid,
 305     0
 306 };
 307 static dispex_static_data_t HTMLDOMImplementation_dispex = {
 308     L"DOMImplementation",
 309     NULL,
 310     DispHTMLDOMImplementation_tid,
 311     HTMLDOMImplementation_iface_tids,
 312     HTMLDOMImplementation_init_dispex_info
 313 };
 314
 315 HRESULT create_dom_implementation(HTMLDocumentNode *doc_node, IHTMLDOMImplementation **ret)
 316 {
 317     HTMLDOMImplementation *dom_implementation;
 318     nsresult nsres;
 319
 320     if(!doc_node->browser)
 321         return E_UNEXPECTED;
 322
 323     dom_implementation = calloc(1, sizeof(*dom_implementation));
 324     if(!dom_implementation)
 325         return E_OUTOFMEMORY;
 326
 327     dom_implementation->IHTMLDOMImplementation_iface.lpVtbl = &HTMLDOMImplementationVtbl;
 328     dom_implementation->IHTMLDOMImplementation2_iface.lpVtbl = &HTMLDOMImplementation2Vtbl;
 329     dom_implementation->ref = 1;
 330     dom_implementation->browser = doc_node->browser;
 331
 332     init_dispatch(&dom_implementation->dispex, (IUnknown*)&dom_implementation->IHTMLDOMImplementation_iface,
 333                   &HTMLDOMImplementation_dispex, doc_node->document_mode);
 334
 335     nsres = nsIDOMDocument_GetImplementation(doc_node->dom_document, &dom_implementation->implementation);
 336     if(NS_FAILED(nsres)) {
 337         ERR("GetDOMImplementation failed: %08lx\n", nsres);
 338         IHTMLDOMImplementation_Release(&dom_implementation->IHTMLDOMImplementation_iface);
 339         return E_FAIL;
 340     }
 341
 342     *ret = &dom_implementation->IHTMLDOMImplementation_iface;
 343     return S_OK;
 344 }
 345
 346 void detach_dom_implementation(IHTMLDOMImplementation *iface)
 347 {
 348     HTMLDOMImplementation *dom_implementation = impl_from_IHTMLDOMImplementation(iface);
 349     dom_implementation->browser = NULL;
 350 }
 351
 352 typedef struct {
 353     DispatchEx dispex;
 354     IHTMLScreen IHTMLScreen_iface;
 355
 356     LONG ref;
 357 } HTMLScreen;
 358
 359 static inline HTMLScreen *impl_from_IHTMLScreen(IHTMLScreen *iface)
 360 {
 361     return CONTAINING_RECORD(iface, HTMLScreen, IHTMLScreen_iface);
 362 }
 363
 364 static HRESULT WINAPI HTMLScreen_QueryInterface(IHTMLScreen *iface, REFIID riid, void **ppv)
 365 {
 366     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 367
 368     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 369
 370     if(IsEqualGUID(&IID_IUnknown, riid)) {
 371         *ppv = &This->IHTMLScreen_iface;
 372     }else if(IsEqualGUID(&IID_IHTMLScreen, riid)) {
 373         *ppv = &This->IHTMLScreen_iface;
 374     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 375         return *ppv ? S_OK : E_NOINTERFACE;
 376     }else {
 377         *ppv = NULL;
 378         WARN("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 379         return E_NOINTERFACE;
 380     }
 381
 382     IUnknown_AddRef((IUnknown*)*ppv);
 383     return S_OK;
 384 }
 385
 386 static ULONG WINAPI HTMLScreen_AddRef(IHTMLScreen *iface)
 387 {
 388     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 389     LONG ref = InterlockedIncrement(&This->ref);
 390
 391     TRACE("(%p) ref=%ld\n", This, ref);
 392
 393     return ref;
 394 }
 395
 396 static ULONG WINAPI HTMLScreen_Release(IHTMLScreen *iface)
 397 {
 398     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 399     LONG ref = InterlockedDecrement(&This->ref);
 400
 401     TRACE("(%p) ref=%ld\n", This, ref);
 402
 403     if(!ref) {
 404         release_dispex(&This->dispex);
 405         free(This);
 406     }
 407
 408     return ref;
 409 }
 410
 411 static HRESULT WINAPI HTMLScreen_GetTypeInfoCount(IHTMLScreen *iface, UINT *pctinfo)
 412 {
 413     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 414     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 415 }
 416
 417 static HRESULT WINAPI HTMLScreen_GetTypeInfo(IHTMLScreen *iface, UINT iTInfo,
 418         LCID lcid, ITypeInfo **ppTInfo)
 419 {
 420     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 421     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 422 }
 423
 424 static HRESULT WINAPI HTMLScreen_GetIDsOfNames(IHTMLScreen *iface, REFIID riid,
 425         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 426 {
 427     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 428     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 429             lcid, rgDispId);
 430 }
 431
 432 static HRESULT WINAPI HTMLScreen_Invoke(IHTMLScreen *iface, DISPID dispIdMember,
 433         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
 434         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 435 {
 436     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 437     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 438             pDispParams, pVarResult, pExcepInfo, puArgErr);
 439 }
 440
 441 static HRESULT WINAPI HTMLScreen_get_colorDepth(IHTMLScreen *iface, LONG *p)
 442 {
 443     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 444     HDC hdc = GetDC(0);
 445
 446     TRACE("(%p)->(%p)\n", This, p);
 447
 448     *p = GetDeviceCaps(hdc, BITSPIXEL);
 449     ReleaseDC(0, hdc);
 450     return S_OK;
 451 }
 452
 453 static HRESULT WINAPI HTMLScreen_put_bufferDepth(IHTMLScreen *iface, LONG v)
 454 {
 455     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 456     FIXME("(%p)->(%ld)\n", This, v);
 457     return E_NOTIMPL;
 458 }
 459
 460 static HRESULT WINAPI HTMLScreen_get_bufferDepth(IHTMLScreen *iface, LONG *p)
 461 {
 462     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 463     FIXME("(%p)->(%p)\n", This, p);
 464     return E_NOTIMPL;
 465 }
 466
 467 static HRESULT WINAPI HTMLScreen_get_width(IHTMLScreen *iface, LONG *p)
 468 {
 469     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 470
 471     TRACE("(%p)->(%p)\n", This, p);
 472
 473     *p = GetSystemMetrics(SM_CXSCREEN);
 474     return S_OK;
 475 }
 476
 477 static HRESULT WINAPI HTMLScreen_get_height(IHTMLScreen *iface, LONG *p)
 478 {
 479     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 480
 481     TRACE("(%p)->(%p)\n", This, p);
 482
 483     *p = GetSystemMetrics(SM_CYSCREEN);
 484     return S_OK;
 485 }
 486
 487 static HRESULT WINAPI HTMLScreen_put_updateInterval(IHTMLScreen *iface, LONG v)
 488 {
 489     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 490     FIXME("(%p)->(%ld)\n", This, v);
 491     return E_NOTIMPL;
 492 }
 493
 494 static HRESULT WINAPI HTMLScreen_get_updateInterval(IHTMLScreen *iface, LONG *p)
 495 {
 496     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 497     FIXME("(%p)->(%p)\n", This, p);
 498     return E_NOTIMPL;
 499 }
 500
 501 static HRESULT WINAPI HTMLScreen_get_availHeight(IHTMLScreen *iface, LONG *p)
 502 {
 503     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 504     RECT work_area;
 505
 506     TRACE("(%p)->(%p)\n", This, p);
 507
 508     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 509         return E_FAIL;
 510
 511     *p = work_area.bottom-work_area.top;
 512     return S_OK;
 513 }
 514
 515 static HRESULT WINAPI HTMLScreen_get_availWidth(IHTMLScreen *iface, LONG *p)
 516 {
 517     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 518     RECT work_area;
 519
 520     TRACE("(%p)->(%p)\n", This, p);
 521
 522     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 523         return E_FAIL;
 524
 525     *p = work_area.right-work_area.left;
 526     return S_OK;
 527 }
 528
 529 static HRESULT WINAPI HTMLScreen_get_fontSmoothingEnabled(IHTMLScreen *iface, VARIANT_BOOL *p)
 530 {
 531     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 532     FIXME("(%p)->(%p)\n", This, p);
 533     return E_NOTIMPL;
 534 }
 535
 536 static const IHTMLScreenVtbl HTMLSreenVtbl = {
 537     HTMLScreen_QueryInterface,
 538     HTMLScreen_AddRef,
 539     HTMLScreen_Release,
 540     HTMLScreen_GetTypeInfoCount,
 541     HTMLScreen_GetTypeInfo,
 542     HTMLScreen_GetIDsOfNames,
 543     HTMLScreen_Invoke,
 544     HTMLScreen_get_colorDepth,
 545     HTMLScreen_put_bufferDepth,
 546     HTMLScreen_get_bufferDepth,
 547     HTMLScreen_get_width,
 548     HTMLScreen_get_height,
 549     HTMLScreen_put_updateInterval,
 550     HTMLScreen_get_updateInterval,
 551     HTMLScreen_get_availHeight,
 552     HTMLScreen_get_availWidth,
 553     HTMLScreen_get_fontSmoothingEnabled
 554 };
 555
 556 static const tid_t HTMLScreen_iface_tids[] = {
 557     IHTMLScreen_tid,
 558     0
 559 };
 560 static dispex_static_data_t HTMLScreen_dispex = {
 561     L"Screen",
 562     NULL,
 563     DispHTMLScreen_tid,
 564     HTMLScreen_iface_tids
 565 };
 566
 567 HRESULT create_html_screen(compat_mode_t compat_mode, IHTMLScreen **ret)
 568 {
 569     HTMLScreen *screen;
 570
 571     screen = calloc(1, sizeof(HTMLScreen));
 572     if(!screen)
 573         return E_OUTOFMEMORY;
 574
 575     screen->IHTMLScreen_iface.lpVtbl = &HTMLSreenVtbl;
 576     screen->ref = 1;
 577
 578     init_dispatch(&screen->dispex, (IUnknown*)&screen->IHTMLScreen_iface, &HTMLScreen_dispex, compat_mode);
 579
 580     *ret = &screen->IHTMLScreen_iface;
 581     return S_OK;
 582 }
 583
 584 static inline OmHistory *impl_from_IOmHistory(IOmHistory *iface)
 585 {
 586     return CONTAINING_RECORD(iface, OmHistory, IOmHistory_iface);
 587 }
 588
 589 static HRESULT WINAPI OmHistory_QueryInterface(IOmHistory *iface, REFIID riid, void **ppv)
 590 {
 591     OmHistory *This = impl_from_IOmHistory(iface);
 592
 593     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 594
 595     if(IsEqualGUID(&IID_IUnknown, riid)) {
 596         *ppv = &This->IOmHistory_iface;
 597     }else if(IsEqualGUID(&IID_IOmHistory, riid)) {
 598         *ppv = &This->IOmHistory_iface;
 599     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 600         return *ppv ? S_OK : E_NOINTERFACE;
 601     }else {
 602         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 603         *ppv = NULL;
 604         return E_NOINTERFACE;
 605     }
 606
 607     IUnknown_AddRef((IUnknown*)*ppv);
 608     return S_OK;
 609 }
 610
 611 static ULONG WINAPI OmHistory_AddRef(IOmHistory *iface)
 612 {
 613     OmHistory *This = impl_from_IOmHistory(iface);
 614     LONG ref = InterlockedIncrement(&This->ref);
 615
 616     TRACE("(%p) ref=%ld\n", This, ref);
 617
 618     return ref;
 619 }
 620
 621 static ULONG WINAPI OmHistory_Release(IOmHistory *iface)
 622 {
 623     OmHistory *This = impl_from_IOmHistory(iface);
 624     LONG ref = InterlockedDecrement(&This->ref);
 625
 626     TRACE("(%p) ref=%ld\n", This, ref);
 627
 628     if(!ref) {
 629         release_dispex(&This->dispex);
 630         free(This);
 631     }
 632
 633     return ref;
 634 }
 635
 636 static HRESULT WINAPI OmHistory_GetTypeInfoCount(IOmHistory *iface, UINT *pctinfo)
 637 {
 638     OmHistory *This = impl_from_IOmHistory(iface);
 639     FIXME("(%p)->(%p)\n", This, pctinfo);
 640     return E_NOTIMPL;
 641 }
 642
 643 static HRESULT WINAPI OmHistory_GetTypeInfo(IOmHistory *iface, UINT iTInfo,
 644         LCID lcid, ITypeInfo **ppTInfo)
 645 {
 646     OmHistory *This = impl_from_IOmHistory(iface);
 647
 648     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 649 }
 650
 651 static HRESULT WINAPI OmHistory_GetIDsOfNames(IOmHistory *iface, REFIID riid, LPOLESTR *rgszNames, UINT cNames,
 652         LCID lcid, DISPID *rgDispId)
 653 {
 654     OmHistory *This = impl_from_IOmHistory(iface);
 655
 656     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 657             lcid, rgDispId);
 658 }
 659
 660 static HRESULT WINAPI OmHistory_Invoke(IOmHistory *iface, DISPID dispIdMember, REFIID riid, LCID lcid,
 661         WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
 662 {
 663     OmHistory *This = impl_from_IOmHistory(iface);
 664
 665     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
 666             pDispParams, pVarResult, pExcepInfo, puArgErr);
 667 }
 668
 669 static HRESULT WINAPI OmHistory_get_length(IOmHistory *iface, short *p)
 670 {
 671     OmHistory *This = impl_from_IOmHistory(iface);
 672     GeckoBrowser *browser = NULL;
 673
 674     TRACE("(%p)->(%p)\n", This, p);
 675
 676     if(This->window && This->window->base.outer_window)
 677         browser = This->window->base.outer_window->browser;
 678
 679     *p = browser && browser->doc->travel_log
 680         ? ITravelLog_CountEntries(browser->doc->travel_log, browser->doc->browser_service)
 681         : 0;
 682     return S_OK;
 683 }
 684
 685 static HRESULT WINAPI OmHistory_back(IOmHistory *iface, VARIANT *pvargdistance)
 686 {
 687     OmHistory *This = impl_from_IOmHistory(iface);
 688     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 689     return E_NOTIMPL;
 690 }
 691
 692 static HRESULT WINAPI OmHistory_forward(IOmHistory *iface, VARIANT *pvargdistance)
 693 {
 694     OmHistory *This = impl_from_IOmHistory(iface);
 695     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 696     return E_NOTIMPL;
 697 }
 698
 699 static HRESULT WINAPI OmHistory_go(IOmHistory *iface, VARIANT *pvargdistance)
 700 {
 701     OmHistory *This = impl_from_IOmHistory(iface);
 702     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 703     return E_NOTIMPL;
 704 }
 705
 706 static const IOmHistoryVtbl OmHistoryVtbl = {
 707     OmHistory_QueryInterface,
 708     OmHistory_AddRef,
 709     OmHistory_Release,
 710     OmHistory_GetTypeInfoCount,
 711     OmHistory_GetTypeInfo,
 712     OmHistory_GetIDsOfNames,
 713     OmHistory_Invoke,
 714     OmHistory_get_length,
 715     OmHistory_back,
 716     OmHistory_forward,
 717     OmHistory_go
 718 };
 719
 720 static const tid_t OmHistory_iface_tids[] = {
 721     IOmHistory_tid,
 722     0
 723 };
 724 static dispex_static_data_t OmHistory_dispex = {
 725     L"History",
 726     NULL,
 727     DispHTMLHistory_tid,
 728     OmHistory_iface_tids
 729 };
 730
 731
 732 HRESULT create_history(HTMLInnerWindow *window, OmHistory **ret)
 733 {
 734     OmHistory *history;
 735
 736     history = calloc(1, sizeof(*history));
 737     if(!history)
 738         return E_OUTOFMEMORY;
 739
 740     init_dispatch(&history->dispex, (IUnknown*)&history->IOmHistory_iface, &OmHistory_dispex,
 741                   dispex_compat_mode(&window->event_target.dispex));
 742     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 743     history->ref = 1;
 744
 745     history->window = window;
 746
 747     *ret = history;
 748     return S_OK;
 749 }
 750
 751 struct HTMLPluginsCollection {
 752     DispatchEx dispex;
 753     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 754
 755     LONG ref;
 756
 757     OmNavigator *navigator;
 758 };
 759
 760 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 761 {
 762     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 763 }
 764
 765 static HRESULT WINAPI HTMLPluginsCollection_QueryInterface(IHTMLPluginsCollection *iface, REFIID riid, void **ppv)
 766 {
 767     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 768
 769     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 770
 771     if(IsEqualGUID(&IID_IUnknown, riid)) {
 772         *ppv = &This->IHTMLPluginsCollection_iface;
 773     }else if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid)) {
 774         *ppv = &This->IHTMLPluginsCollection_iface;
 775     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 776         return *ppv ? S_OK : E_NOINTERFACE;
 777     }else {
 778         *ppv = NULL;
 779         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 780         return E_NOINTERFACE;
 781     }
 782
 783     IUnknown_AddRef((IUnknown*)*ppv);
 784     return S_OK;
 785 }
 786
 787 static ULONG WINAPI HTMLPluginsCollection_AddRef(IHTMLPluginsCollection *iface)
 788 {
 789     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 790     LONG ref = InterlockedIncrement(&This->ref);
 791
 792     TRACE("(%p) ref=%ld\n", This, ref);
 793
 794     return ref;
 795 }
 796
 797 static ULONG WINAPI HTMLPluginsCollection_Release(IHTMLPluginsCollection *iface)
 798 {
 799     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 800     LONG ref = InterlockedDecrement(&This->ref);
 801
 802     TRACE("(%p) ref=%ld\n", This, ref);
 803
 804     if(!ref) {
 805         if(This->navigator)
 806             This->navigator->plugins = NULL;
 807         release_dispex(&This->dispex);
 808         free(This);
 809     }
 810
 811     return ref;
 812 }
 813
 814 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfoCount(IHTMLPluginsCollection *iface, UINT *pctinfo)
 815 {
 816     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 817     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 818 }
 819
 820 static HRESULT WINAPI HTMLPluginsCollection_GetTypeInfo(IHTMLPluginsCollection *iface, UINT iTInfo,
 821                                               LCID lcid, ITypeInfo **ppTInfo)
 822 {
 823     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 824     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 825 }
 826
 827 static HRESULT WINAPI HTMLPluginsCollection_GetIDsOfNames(IHTMLPluginsCollection *iface, REFIID riid,
 828         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 829 {
 830     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 831     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 832             lcid, rgDispId);
 833 }
 834
 835 static HRESULT WINAPI HTMLPluginsCollection_Invoke(IHTMLPluginsCollection *iface, DISPID dispIdMember,
 836         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 837         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 838 {
 839     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 840     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 841             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 842 }
 843
 844 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 845 {
 846     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 847
 848     TRACE("(%p)->(%p)\n", This, p);
 849
 850     /* IE always returns 0 here */
 851     *p = 0;
 852     return S_OK;
 853 }
 854
 855 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 856 {
 857     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 858
 859     TRACE("(%p)->(%x)\n", This, reload);
 860
 861     /* Nothing to do here. */
 862     return S_OK;
 863 }
 864
 865 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 866     HTMLPluginsCollection_QueryInterface,
 867     HTMLPluginsCollection_AddRef,
 868     HTMLPluginsCollection_Release,
 869     HTMLPluginsCollection_GetTypeInfoCount,
 870     HTMLPluginsCollection_GetTypeInfo,
 871     HTMLPluginsCollection_GetIDsOfNames,
 872     HTMLPluginsCollection_Invoke,
 873     HTMLPluginsCollection_get_length,
 874     HTMLPluginsCollection_refresh
 875 };
 876
 877 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 878     IHTMLPluginsCollection_tid,
 879     0
 880 };
 881 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 882     L"PluginArray",
 883     NULL,
 884     DispCPlugins_tid,
 885     HTMLPluginsCollection_iface_tids
 886 };
 887
 888 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 889 {
 890     HTMLPluginsCollection *col;
 891
 892     col = calloc(1, sizeof(*col));
 893     if(!col)
 894         return E_OUTOFMEMORY;
 895
 896     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 897     col->ref = 1;
 898     col->navigator = navigator;
 899
 900     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLPluginsCollection_iface,
 901                   &HTMLPluginsCollection_dispex, dispex_compat_mode(&navigator->dispex));
 902
 903     *ret = col;
 904     return S_OK;
 905 }
 906
 907 struct HTMLMimeTypesCollection {
 908     DispatchEx dispex;
 909     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 910
 911     LONG ref;
 912
 913     OmNavigator *navigator;
 914 };
 915
 916 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 917 {
 918     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 919 }
 920
 921 static HRESULT WINAPI HTMLMimeTypesCollection_QueryInterface(IHTMLMimeTypesCollection *iface, REFIID riid, void **ppv)
 922 {
 923     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 924
 925     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
 926
 927     if(IsEqualGUID(&IID_IUnknown, riid)) {
 928         *ppv = &This->IHTMLMimeTypesCollection_iface;
 929     }else if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid)) {
 930         *ppv = &This->IHTMLMimeTypesCollection_iface;
 931     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
 932         return *ppv ? S_OK : E_NOINTERFACE;
 933     }else {
 934         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
 935         *ppv = NULL;
 936         return E_NOINTERFACE;
 937     }
 938
 939     IUnknown_AddRef((IUnknown*)*ppv);
 940     return S_OK;
 941 }
 942
 943 static ULONG WINAPI HTMLMimeTypesCollection_AddRef(IHTMLMimeTypesCollection *iface)
 944 {
 945     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 946     LONG ref = InterlockedIncrement(&This->ref);
 947
 948     TRACE("(%p) ref=%ld\n", This, ref);
 949
 950     return ref;
 951 }
 952
 953 static ULONG WINAPI HTMLMimeTypesCollection_Release(IHTMLMimeTypesCollection *iface)
 954 {
 955     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 956     LONG ref = InterlockedDecrement(&This->ref);
 957
 958     TRACE("(%p) ref=%ld\n", This, ref);
 959
 960     if(!ref) {
 961         if(This->navigator)
 962             This->navigator->mime_types = NULL;
 963         release_dispex(&This->dispex);
 964         free(This);
 965     }
 966
 967     return ref;
 968 }
 969
 970 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfoCount(IHTMLMimeTypesCollection *iface, UINT *pctinfo)
 971 {
 972     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 973     return IDispatchEx_GetTypeInfoCount(&This->dispex.IDispatchEx_iface, pctinfo);
 974 }
 975
 976 static HRESULT WINAPI HTMLMimeTypesCollection_GetTypeInfo(IHTMLMimeTypesCollection *iface, UINT iTInfo,
 977                                               LCID lcid, ITypeInfo **ppTInfo)
 978 {
 979     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 980     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
 981 }
 982
 983 static HRESULT WINAPI HTMLMimeTypesCollection_GetIDsOfNames(IHTMLMimeTypesCollection *iface, REFIID riid,
 984         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
 985 {
 986     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 987     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
 988             lcid, rgDispId);
 989 }
 990
 991 static HRESULT WINAPI HTMLMimeTypesCollection_Invoke(IHTMLMimeTypesCollection *iface, DISPID dispIdMember,
 992         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams, VARIANT *pVarResult,
 993         EXCEPINFO *pExcepInfo, UINT *puArgErr)
 994 {
 995     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 996     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid,
 997             wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
 998 }
 999
1000 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
1001 {
1002     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
1003
1004     TRACE("(%p)->(%p)\n", This, p);
1005
1006     /* This is just a stub for compatibility with other browser in IE */
1007     *p = 0;
1008     return S_OK;
1009 }
1010
1011 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
1012     HTMLMimeTypesCollection_QueryInterface,
1013     HTMLMimeTypesCollection_AddRef,
1014     HTMLMimeTypesCollection_Release,
1015     HTMLMimeTypesCollection_GetTypeInfoCount,
1016     HTMLMimeTypesCollection_GetTypeInfo,
1017     HTMLMimeTypesCollection_GetIDsOfNames,
1018     HTMLMimeTypesCollection_Invoke,
1019     HTMLMimeTypesCollection_get_length
1020 };
1021
1022 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
1023     IHTMLMimeTypesCollection_tid,
1024     0
1025 };
1026 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
1027     L"MimeTypeArray",
1028     NULL,
1029     IHTMLMimeTypesCollection_tid,
1030     HTMLMimeTypesCollection_iface_tids
1031 };
1032
1033 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
1034 {
1035     HTMLMimeTypesCollection *col;
1036
1037     col = calloc(1, sizeof(*col));
1038     if(!col)
1039         return E_OUTOFMEMORY;
1040
1041     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
1042     col->ref = 1;
1043     col->navigator = navigator;
1044
1045     init_dispatch(&col->dispex, (IUnknown*)&col->IHTMLMimeTypesCollection_iface,
1046                   &HTMLMimeTypesCollection_dispex, dispex_compat_mode(&navigator->dispex));
1047
1048     *ret = col;
1049     return S_OK;
1050 }
1051
1052 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
1053 {
1054     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
1055 }
1056
1057 static HRESULT WINAPI OmNavigator_QueryInterface(IOmNavigator *iface, REFIID riid, void **ppv)
1058 {
1059     OmNavigator *This = impl_from_IOmNavigator(iface);
1060
1061     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1062
1063     if(IsEqualGUID(&IID_IUnknown, riid)) {
1064         *ppv = &This->IOmNavigator_iface;
1065     }else if(IsEqualGUID(&IID_IOmNavigator, riid)) {
1066         *ppv = &This->IOmNavigator_iface;
1067     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1068         return *ppv ? S_OK : E_NOINTERFACE;
1069     }else {
1070         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1071         *ppv = NULL;
1072         return E_NOINTERFACE;
1073     }
1074
1075     IUnknown_AddRef((IUnknown*)*ppv);
1076     return S_OK;
1077 }
1078
1079 static ULONG WINAPI OmNavigator_AddRef(IOmNavigator *iface)
1080 {
1081     OmNavigator *This = impl_from_IOmNavigator(iface);
1082     LONG ref = InterlockedIncrement(&This->ref);
1083
1084     TRACE("(%p) ref=%ld\n", This, ref);
1085
1086     return ref;
1087 }
1088
1089 static ULONG WINAPI OmNavigator_Release(IOmNavigator *iface)
1090 {
1091     OmNavigator *This = impl_from_IOmNavigator(iface);
1092     LONG ref = InterlockedDecrement(&This->ref);
1093
1094     TRACE("(%p) ref=%ld\n", This, ref);
1095
1096     if(!ref) {
1097         if(This->plugins)
1098             This->plugins->navigator = NULL;
1099         if(This->mime_types)
1100             This->mime_types->navigator = NULL;
1101         release_dispex(&This->dispex);
1102         free(This);
1103     }
1104
1105     return ref;
1106 }
1107
1108 static HRESULT WINAPI OmNavigator_GetTypeInfoCount(IOmNavigator *iface, UINT *pctinfo)
1109 {
1110     OmNavigator *This = impl_from_IOmNavigator(iface);
1111     FIXME("(%p)->(%p)\n", This, pctinfo);
1112     return E_NOTIMPL;
1113 }
1114
1115 static HRESULT WINAPI OmNavigator_GetTypeInfo(IOmNavigator *iface, UINT iTInfo,
1116                                               LCID lcid, ITypeInfo **ppTInfo)
1117 {
1118     OmNavigator *This = impl_from_IOmNavigator(iface);
1119
1120     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1121 }
1122
1123 static HRESULT WINAPI OmNavigator_GetIDsOfNames(IOmNavigator *iface, REFIID riid,
1124                                                 LPOLESTR *rgszNames, UINT cNames,
1125                                                 LCID lcid, DISPID *rgDispId)
1126 {
1127     OmNavigator *This = impl_from_IOmNavigator(iface);
1128
1129     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1130             lcid, rgDispId);
1131 }
1132
1133 static HRESULT WINAPI OmNavigator_Invoke(IOmNavigator *iface, DISPID dispIdMember,
1134                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1135                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1136 {
1137     OmNavigator *This = impl_from_IOmNavigator(iface);
1138
1139     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1140             pDispParams, pVarResult, pExcepInfo, puArgErr);
1141 }
1142
1143 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
1144 {
1145     OmNavigator *This = impl_from_IOmNavigator(iface);
1146
1147     TRACE("(%p)->(%p)\n", This, p);
1148
1149     *p = SysAllocString(L"Mozilla");
1150     return S_OK;
1151 }
1152
1153 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
1154 {
1155     OmNavigator *This = impl_from_IOmNavigator(iface);
1156
1157     TRACE("(%p)->(%p)\n", This, p);
1158
1159     *p = SysAllocString(dispex_compat_mode(&This->dispex) == COMPAT_MODE_IE11
1160                         ? L"Netscape" : L"Microsoft Internet Explorer");
1161     if(!*p)
1162         return E_OUTOFMEMORY;
1163
1164     return S_OK;
1165 }
1166
1167 /* undocumented, added in IE8 */
1168 extern HRESULT WINAPI MapBrowserEmulationModeToUserAgent(const void*,WCHAR**);
1169
1170 /* Retrieves allocated user agent via CoTaskMemAlloc */
1171 static HRESULT get_user_agent(OmNavigator *navigator, WCHAR **user_agent)
1172 {
1173     DWORD version = get_compat_mode_version(dispex_compat_mode(&navigator->dispex));
1174
1175     return MapBrowserEmulationModeToUserAgent(&version, user_agent);
1176 }
1177
1178 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
1179 {
1180     OmNavigator *This = impl_from_IOmNavigator(iface);
1181     WCHAR *user_agent;
1182     unsigned len;
1183     HRESULT hres;
1184     const unsigned skip_prefix = 8; /* strlen("Mozilla/") */
1185
1186     TRACE("(%p)->(%p)\n", This, p);
1187
1188     hres = get_user_agent(This, &user_agent);
1189     if(FAILED(hres))
1190         return hres;
1191     len = wcslen(user_agent);
1192
1193     if(len < skip_prefix) {
1194         CoTaskMemFree(user_agent);
1195         *p = NULL;
1196         return S_OK;
1197     }
1198
1199     *p = SysAllocStringLen(user_agent + skip_prefix, len - skip_prefix);
1200     CoTaskMemFree(user_agent);
1201     return *p ? S_OK : E_OUTOFMEMORY;
1202 }
1203
1204 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
1205 {
1206     OmNavigator *This = impl_from_IOmNavigator(iface);
1207     WCHAR *user_agent;
1208     HRESULT hres;
1209
1210     TRACE("(%p)->(%p)\n", This, p);
1211
1212     hres = get_user_agent(This, &user_agent);
1213     if(FAILED(hres))
1214         return hres;
1215
1216     *p = SysAllocString(user_agent);
1217     CoTaskMemFree(user_agent);
1218     return *p ? S_OK : E_OUTOFMEMORY;
1219 }
1220
1221 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1222 {
1223     OmNavigator *This = impl_from_IOmNavigator(iface);
1224
1225     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
1226
1227     *enabled = VARIANT_TRUE;
1228     return S_OK;
1229 }
1230
1231 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
1232 {
1233     OmNavigator *This = impl_from_IOmNavigator(iface);
1234     FIXME("(%p)->(%p)\n", This, enabled);
1235     return E_NOTIMPL;
1236 }
1237
1238 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
1239 {
1240     OmNavigator *This = impl_from_IOmNavigator(iface);
1241
1242     TRACE("(%p)->(%p)\n", This, p);
1243
1244     if(!This->mime_types) {
1245         HRESULT hres;
1246
1247         hres = create_mime_types_collection(This, &This->mime_types);
1248         if(FAILED(hres))
1249             return hres;
1250     }else {
1251         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
1252     }
1253
1254     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
1255     return S_OK;
1256 }
1257
1258 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
1259 {
1260     OmNavigator *This = impl_from_IOmNavigator(iface);
1261
1262     TRACE("(%p)->(%p)\n", This, p);
1263
1264     if(!This->plugins) {
1265         HRESULT hres;
1266
1267         hres = create_plugins_collection(This, &This->plugins);
1268         if(FAILED(hres))
1269             return hres;
1270     }else {
1271         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
1272     }
1273
1274     *p = &This->plugins->IHTMLPluginsCollection_iface;
1275     return S_OK;
1276 }
1277
1278 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
1279 {
1280     OmNavigator *This = impl_from_IOmNavigator(iface);
1281
1282     WARN("(%p)->(%p) semi-stub\n", This, p);
1283
1284     *p = VARIANT_TRUE;
1285     return S_OK;
1286 }
1287
1288 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1289 {
1290     OmNavigator *This = impl_from_IOmNavigator(iface);
1291     FIXME("(%p)->(%p)\n", This, p);
1292     return E_NOTIMPL;
1293 }
1294
1295 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
1296 {
1297     OmNavigator *This = impl_from_IOmNavigator(iface);
1298
1299     TRACE("(%p)->(%p)\n", This, String);
1300
1301     return dispex_to_string(&This->dispex, String);
1302 }
1303
1304 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
1305 {
1306     OmNavigator *This = impl_from_IOmNavigator(iface);
1307
1308     TRACE("(%p)->(%p)\n", This, p);
1309
1310 #ifdef _WIN64
1311     *p = SysAllocString(L"x64");
1312 #else
1313     *p = SysAllocString(L"x86");
1314 #endif
1315     return *p ? S_OK : E_OUTOFMEMORY;
1316 }
1317
1318 static HRESULT get_language_string(LCID lcid, BSTR *p)
1319 {
1320     BSTR ret;
1321     int len;
1322
1323     len = LCIDToLocaleName(lcid, NULL, 0, 0);
1324     if(!len) {
1325         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1326         return E_FAIL;
1327     }
1328
1329     ret = SysAllocStringLen(NULL, len-1);
1330     if(!ret)
1331         return E_OUTOFMEMORY;
1332
1333     len = LCIDToLocaleName(lcid, ret, len, 0);
1334     if(!len) {
1335         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
1336         SysFreeString(ret);
1337         return E_FAIL;
1338     }
1339
1340     *p = ret;
1341     return S_OK;
1342 }
1343
1344 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1345 {
1346     OmNavigator *This = impl_from_IOmNavigator(iface);
1347
1348     TRACE("(%p)->(%p)\n", This, p);
1349
1350     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1351 }
1352
1353 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1354 {
1355     OmNavigator *This = impl_from_IOmNavigator(iface);
1356
1357     TRACE("(%p)->(%p)\n", This, p);
1358
1359     return get_language_string(GetUserDefaultUILanguage(), p);
1360 }
1361
1362 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1363 {
1364     OmNavigator *This = impl_from_IOmNavigator(iface);
1365
1366     TRACE("(%p)->(%p)\n", This, p);
1367
1368     return get_language_string(LOCALE_USER_DEFAULT, p);
1369 }
1370
1371 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1372 {
1373     OmNavigator *This = impl_from_IOmNavigator(iface);
1374
1375     TRACE("(%p)->(%p)\n", This, p);
1376
1377 #ifdef _WIN64
1378     *p = SysAllocString(L"Win64");
1379 #else
1380     *p = SysAllocString(L"Win32");
1381 #endif
1382     return S_OK;
1383 }
1384
1385 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1386 {
1387     OmNavigator *This = impl_from_IOmNavigator(iface);
1388
1389     TRACE("(%p)->(%p)\n", This, p);
1390
1391     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1392     *p = SysAllocString(L"0");
1393     return S_OK;
1394 }
1395
1396 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1397 {
1398     OmNavigator *This = impl_from_IOmNavigator(iface);
1399     FIXME("(%p)->(%p)\n", This, p);
1400     return E_NOTIMPL;
1401 }
1402
1403 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1404 {
1405     OmNavigator *This = impl_from_IOmNavigator(iface);
1406
1407     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1408
1409     *p = VARIANT_TRUE;
1410     return S_OK;
1411 }
1412
1413 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1414 {
1415     OmNavigator *This = impl_from_IOmNavigator(iface);
1416     FIXME("(%p)->(%p)\n", This, p);
1417     return E_NOTIMPL;
1418 }
1419
1420 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1421     OmNavigator_QueryInterface,
1422     OmNavigator_AddRef,
1423     OmNavigator_Release,
1424     OmNavigator_GetTypeInfoCount,
1425     OmNavigator_GetTypeInfo,
1426     OmNavigator_GetIDsOfNames,
1427     OmNavigator_Invoke,
1428     OmNavigator_get_appCodeName,
1429     OmNavigator_get_appName,
1430     OmNavigator_get_appVersion,
1431     OmNavigator_get_userAgent,
1432     OmNavigator_javaEnabled,
1433     OmNavigator_taintEnabled,
1434     OmNavigator_get_mimeTypes,
1435     OmNavigator_get_plugins,
1436     OmNavigator_get_cookieEnabled,
1437     OmNavigator_get_opsProfile,
1438     OmNavigator_toString,
1439     OmNavigator_get_cpuClass,
1440     OmNavigator_get_systemLanguage,
1441     OmNavigator_get_browserLanguage,
1442     OmNavigator_get_userLanguage,
1443     OmNavigator_get_platform,
1444     OmNavigator_get_appMinorVersion,
1445     OmNavigator_get_connectionSpeed,
1446     OmNavigator_get_onLine,
1447     OmNavigator_get_userProfile
1448 };
1449
1450 static const tid_t OmNavigator_iface_tids[] = {
1451     IOmNavigator_tid,
1452     0
1453 };
1454 static dispex_static_data_t OmNavigator_dispex = {
1455     L"Navigator",
1456     NULL,
1457     DispHTMLNavigator_tid,
1458     OmNavigator_iface_tids
1459 };
1460
1461 HRESULT create_navigator(compat_mode_t compat_mode, IOmNavigator **navigator)
1462 {
1463     OmNavigator *ret;
1464
1465     ret = calloc(1, sizeof(*ret));
1466     if(!ret)
1467         return E_OUTOFMEMORY;
1468
1469     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1470     ret->ref = 1;
1471
1472     init_dispatch(&ret->dispex, (IUnknown*)&ret->IOmNavigator_iface, &OmNavigator_dispex, compat_mode);
1473
1474     *navigator = &ret->IOmNavigator_iface;
1475     return S_OK;
1476 }
1477
1478 static inline HTMLPerformanceTiming *impl_from_IHTMLPerformanceTiming(IHTMLPerformanceTiming *iface)
1479 {
1480     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, IHTMLPerformanceTiming_iface);
1481 }
1482
1483 static HRESULT WINAPI HTMLPerformanceTiming_QueryInterface(IHTMLPerformanceTiming *iface, REFIID riid, void **ppv)
1484 {
1485     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1486
1487     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1488
1489     if(IsEqualGUID(&IID_IUnknown, riid)) {
1490         *ppv = &This->IHTMLPerformanceTiming_iface;
1491     }else if(IsEqualGUID(&IID_IHTMLPerformanceTiming, riid)) {
1492         *ppv = &This->IHTMLPerformanceTiming_iface;
1493     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1494         return *ppv ? S_OK : E_NOINTERFACE;
1495     }else {
1496         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1497         *ppv = NULL;
1498         return E_NOINTERFACE;
1499     }
1500
1501     IUnknown_AddRef((IUnknown*)*ppv);
1502     return S_OK;
1503 }
1504
1505 static ULONG WINAPI HTMLPerformanceTiming_AddRef(IHTMLPerformanceTiming *iface)
1506 {
1507     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1508     LONG ref = InterlockedIncrement(&This->ref);
1509
1510     TRACE("(%p) ref=%ld\n", This, ref);
1511
1512     return ref;
1513 }
1514
1515 static ULONG WINAPI HTMLPerformanceTiming_Release(IHTMLPerformanceTiming *iface)
1516 {
1517     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1518     LONG ref = InterlockedDecrement(&This->ref);
1519
1520     TRACE("(%p) ref=%ld\n", This, ref);
1521
1522     if(!ref) {
1523         if(This->dispex.outer)
1524             release_dispex(&This->dispex);
1525         free(This);
1526     }
1527
1528     return ref;
1529 }
1530
1531 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfoCount(IHTMLPerformanceTiming *iface, UINT *pctinfo)
1532 {
1533     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1534     FIXME("(%p)->(%p)\n", This, pctinfo);
1535     return E_NOTIMPL;
1536 }
1537
1538 static HRESULT WINAPI HTMLPerformanceTiming_GetTypeInfo(IHTMLPerformanceTiming *iface, UINT iTInfo,
1539                                               LCID lcid, ITypeInfo **ppTInfo)
1540 {
1541     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1542
1543     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1544 }
1545
1546 static HRESULT WINAPI HTMLPerformanceTiming_GetIDsOfNames(IHTMLPerformanceTiming *iface, REFIID riid,
1547                                                           LPOLESTR *rgszNames, UINT cNames,
1548                                                           LCID lcid, DISPID *rgDispId)
1549 {
1550     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1551
1552     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1553             lcid, rgDispId);
1554 }
1555
1556 static HRESULT WINAPI HTMLPerformanceTiming_Invoke(IHTMLPerformanceTiming *iface, DISPID dispIdMember,
1557                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1558                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1559 {
1560     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1561
1562     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1563             pDispParams, pVarResult, pExcepInfo, puArgErr);
1564 }
1565
1566 static ULONGLONG get_fetch_time(HTMLPerformanceTiming *This)
1567 {
1568     /* If there's no prior doc unloaded and no redirects, fetch time == navigationStart time */
1569     if(!This->unload_event_end_time && !This->redirect_time)
1570         return This->navigation_start_time;
1571
1572     if(This->dns_lookup_time)
1573         return This->dns_lookup_time;
1574     if(This->connect_time)
1575         return This->connect_time;
1576     if(This->request_time)
1577         return This->request_time;
1578     if(This->unload_event_end_time)
1579         return This->unload_event_end_time;
1580
1581     return This->redirect_time;
1582 }
1583
1584 static HRESULT WINAPI HTMLPerformanceTiming_get_navigationStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1585 {
1586     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1587
1588     TRACE("(%p)->(%p)\n", This, p);
1589
1590     *p = This->navigation_start_time;
1591     return S_OK;
1592 }
1593
1594 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1595 {
1596     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1597
1598     TRACE("(%p)->(%p)\n", This, p);
1599
1600     *p = This->unload_event_start_time;
1601     return S_OK;
1602 }
1603
1604 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1605 {
1606     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1607
1608     TRACE("(%p)->(%p)\n", This, p);
1609
1610     *p = This->unload_event_end_time;
1611     return S_OK;
1612 }
1613
1614 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1615 {
1616     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1617
1618     TRACE("(%p)->(%p)\n", This, p);
1619
1620     *p = This->redirect_time;
1621     return S_OK;
1622 }
1623
1624 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1625 {
1626     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1627
1628     TRACE("(%p)->(%p)\n", This, p);
1629
1630     *p = This->redirect_time ? get_fetch_time(This) : 0;
1631     return S_OK;
1632 }
1633
1634 static HRESULT WINAPI HTMLPerformanceTiming_get_fetchStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1635 {
1636     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1637
1638     TRACE("(%p)->(%p)\n", This, p);
1639
1640     *p = get_fetch_time(This);
1641     return S_OK;
1642 }
1643
1644 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1645 {
1646     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1647
1648     TRACE("(%p)->(%p)\n", This, p);
1649
1650     *p = This->dns_lookup_time ? This->dns_lookup_time : get_fetch_time(This);
1651     return S_OK;
1652 }
1653
1654 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1655 {
1656     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1657
1658     TRACE("(%p)->(%p)\n", This, p);
1659
1660     *p = This->connect_time    ? This->connect_time    :
1661          This->dns_lookup_time ? This->dns_lookup_time : get_fetch_time(This);
1662     return S_OK;
1663 }
1664
1665 static HRESULT WINAPI HTMLPerformanceTiming_get_connectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1666 {
1667     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1668
1669     TRACE("(%p)->(%p)\n", This, p);
1670
1671     *p = This->connect_time    ? This->connect_time    :
1672          This->dns_lookup_time ? This->dns_lookup_time : get_fetch_time(This);
1673     return S_OK;
1674 }
1675
1676 static HRESULT WINAPI HTMLPerformanceTiming_get_connectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1677 {
1678     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1679
1680     TRACE("(%p)->(%p)\n", This, p);
1681
1682     *p = This->request_time    ? This->request_time    :
1683          This->connect_time    ? This->connect_time    :
1684          This->dns_lookup_time ? This->dns_lookup_time : get_fetch_time(This);
1685     return S_OK;
1686 }
1687
1688 static HRESULT WINAPI HTMLPerformanceTiming_get_requestStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1689 {
1690     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1691
1692     TRACE("(%p)->(%p)\n", This, p);
1693
1694     *p = This->request_time    ? This->request_time    :
1695          This->connect_time    ? This->connect_time    :
1696          This->dns_lookup_time ? This->dns_lookup_time : get_fetch_time(This);
1697     return S_OK;
1698 }
1699
1700 static HRESULT WINAPI HTMLPerformanceTiming_get_responseStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1701 {
1702     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1703
1704     TRACE("(%p)->(%p)\n", This, p);
1705
1706     *p = This->response_start_time;
1707     return S_OK;
1708 }
1709
1710 static HRESULT WINAPI HTMLPerformanceTiming_get_responseEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1711 {
1712     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1713
1714     TRACE("(%p)->(%p)\n", This, p);
1715
1716     *p = This->response_end_time;
1717     return S_OK;
1718 }
1719
1720 static HRESULT WINAPI HTMLPerformanceTiming_get_domLoading(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1721 {
1722     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1723
1724     TRACE("(%p)->(%p)\n", This, p);
1725
1726     /* Make sure this is after responseEnd, when the Gecko parser starts */
1727     *p = This->response_end_time;
1728     return S_OK;
1729 }
1730
1731 static HRESULT WINAPI HTMLPerformanceTiming_get_domInteractive(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1732 {
1733     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1734
1735     TRACE("(%p)->(%p)\n", This, p);
1736
1737     *p = This->dom_interactive_time;
1738     return S_OK;
1739 }
1740
1741 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1742 {
1743     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1744
1745     TRACE("(%p)->(%p)\n", This, p);
1746
1747     *p = This->dom_content_loaded_event_start_time;
1748     return S_OK;
1749 }
1750
1751 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1752 {
1753     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1754
1755     TRACE("(%p)->(%p)\n", This, p);
1756
1757     *p = This->dom_content_loaded_event_end_time;
1758     return S_OK;
1759 }
1760
1761 static HRESULT WINAPI HTMLPerformanceTiming_get_domComplete(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1762 {
1763     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1764
1765     TRACE("(%p)->(%p)\n", This, p);
1766
1767     *p = This->dom_complete_time;
1768     return S_OK;
1769 }
1770
1771 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1772 {
1773     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1774
1775     TRACE("(%p)->(%p)\n", This, p);
1776
1777     *p = This->load_event_start_time;
1778     return S_OK;
1779 }
1780
1781 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1782 {
1783     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1784
1785     TRACE("(%p)->(%p)\n", This, p);
1786
1787     *p = This->load_event_end_time;
1788     return S_OK;
1789 }
1790
1791 static HRESULT WINAPI HTMLPerformanceTiming_get_msFirstPaint(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1792 {
1793     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1794
1795     TRACE("(%p)->(%p)\n", This, p);
1796
1797     *p = This->first_paint_time;
1798     return S_OK;
1799 }
1800
1801 static HRESULT WINAPI HTMLPerformanceTiming_toString(IHTMLPerformanceTiming *iface, BSTR *string)
1802 {
1803     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1804
1805     TRACE("(%p)->(%p)\n", This, string);
1806
1807     return dispex_to_string(&This->dispex, string);
1808 }
1809
1810 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1811 {
1812     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1813     FIXME("(%p)->(%p)\n", This, p);
1814     return E_NOTIMPL;
1815 }
1816
1817 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1818     HTMLPerformanceTiming_QueryInterface,
1819     HTMLPerformanceTiming_AddRef,
1820     HTMLPerformanceTiming_Release,
1821     HTMLPerformanceTiming_GetTypeInfoCount,
1822     HTMLPerformanceTiming_GetTypeInfo,
1823     HTMLPerformanceTiming_GetIDsOfNames,
1824     HTMLPerformanceTiming_Invoke,
1825     HTMLPerformanceTiming_get_navigationStart,
1826     HTMLPerformanceTiming_get_unloadEventStart,
1827     HTMLPerformanceTiming_get_unloadEventEnd,
1828     HTMLPerformanceTiming_get_redirectStart,
1829     HTMLPerformanceTiming_get_redirectEnd,
1830     HTMLPerformanceTiming_get_fetchStart,
1831     HTMLPerformanceTiming_get_domainLookupStart,
1832     HTMLPerformanceTiming_get_domainLookupEnd,
1833     HTMLPerformanceTiming_get_connectStart,
1834     HTMLPerformanceTiming_get_connectEnd,
1835     HTMLPerformanceTiming_get_requestStart,
1836     HTMLPerformanceTiming_get_responseStart,
1837     HTMLPerformanceTiming_get_responseEnd,
1838     HTMLPerformanceTiming_get_domLoading,
1839     HTMLPerformanceTiming_get_domInteractive,
1840     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1841     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1842     HTMLPerformanceTiming_get_domComplete,
1843     HTMLPerformanceTiming_get_loadEventStart,
1844     HTMLPerformanceTiming_get_loadEventEnd,
1845     HTMLPerformanceTiming_get_msFirstPaint,
1846     HTMLPerformanceTiming_toString,
1847     HTMLPerformanceTiming_toJSON
1848 };
1849
1850 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1851     IHTMLPerformanceTiming_tid,
1852     0
1853 };
1854 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1855     L"PerformanceTiming",
1856     NULL,
1857     IHTMLPerformanceTiming_tid,
1858     HTMLPerformanceTiming_iface_tids
1859 };
1860
1861 HRESULT create_performance_timing(HTMLPerformanceTiming **ret)
1862 {
1863     HTMLPerformanceTiming *timing;
1864
1865     timing = calloc(1, sizeof(*timing));
1866     if(!timing)
1867         return E_OUTOFMEMORY;
1868
1869     timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
1870     timing->ref = 1;
1871
1872     /* Defer initializing the dispex until it's actually needed (for compat mode) */
1873     *ret = timing;
1874     return S_OK;
1875 }
1876
1877 typedef struct {
1878     DispatchEx dispex;
1879     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1880
1881     LONG ref;
1882     HTMLPerformanceTiming *timing;
1883 } HTMLPerformanceNavigation;
1884
1885 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1886 {
1887     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1888 }
1889
1890 static HRESULT WINAPI HTMLPerformanceNavigation_QueryInterface(IHTMLPerformanceNavigation *iface, REFIID riid, void **ppv)
1891 {
1892     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1893
1894     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
1895
1896     if(IsEqualGUID(&IID_IUnknown, riid)) {
1897         *ppv = &This->IHTMLPerformanceNavigation_iface;
1898     }else if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid)) {
1899         *ppv = &This->IHTMLPerformanceNavigation_iface;
1900     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
1901         return *ppv ? S_OK : E_NOINTERFACE;
1902     }else {
1903         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
1904         *ppv = NULL;
1905         return E_NOINTERFACE;
1906     }
1907
1908     IUnknown_AddRef((IUnknown*)*ppv);
1909     return S_OK;
1910 }
1911
1912 static ULONG WINAPI HTMLPerformanceNavigation_AddRef(IHTMLPerformanceNavigation *iface)
1913 {
1914     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1915     LONG ref = InterlockedIncrement(&This->ref);
1916
1917     TRACE("(%p) ref=%ld\n", This, ref);
1918
1919     return ref;
1920 }
1921
1922 static ULONG WINAPI HTMLPerformanceNavigation_Release(IHTMLPerformanceNavigation *iface)
1923 {
1924     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1925     LONG ref = InterlockedDecrement(&This->ref);
1926
1927     TRACE("(%p) ref=%ld\n", This, ref);
1928
1929     if(!ref) {
1930         IHTMLPerformanceTiming_Release(&This->timing->IHTMLPerformanceTiming_iface);
1931         release_dispex(&This->dispex);
1932         free(This);
1933     }
1934
1935     return ref;
1936 }
1937
1938 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfoCount(IHTMLPerformanceNavigation *iface, UINT *pctinfo)
1939 {
1940     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1941     FIXME("(%p)->(%p)\n", This, pctinfo);
1942     return E_NOTIMPL;
1943 }
1944
1945 static HRESULT WINAPI HTMLPerformanceNavigation_GetTypeInfo(IHTMLPerformanceNavigation *iface, UINT iTInfo,
1946                                               LCID lcid, ITypeInfo **ppTInfo)
1947 {
1948     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1949
1950     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
1951 }
1952
1953 static HRESULT WINAPI HTMLPerformanceNavigation_GetIDsOfNames(IHTMLPerformanceNavigation *iface, REFIID riid,
1954                                                           LPOLESTR *rgszNames, UINT cNames,
1955                                                           LCID lcid, DISPID *rgDispId)
1956 {
1957     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1958
1959     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
1960             lcid, rgDispId);
1961 }
1962
1963 static HRESULT WINAPI HTMLPerformanceNavigation_Invoke(IHTMLPerformanceNavigation *iface, DISPID dispIdMember,
1964                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
1965                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
1966 {
1967     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1968
1969     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
1970             pDispParams, pVarResult, pExcepInfo, puArgErr);
1971 }
1972
1973 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
1974 {
1975     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1976
1977     TRACE("(%p)->(%p)\n", This, p);
1978
1979     *p = This->timing->navigation_type;
1980     return S_OK;
1981 }
1982
1983 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
1984 {
1985     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1986
1987     TRACE("(%p)->(%p)\n", This, p);
1988
1989     *p = This->timing->redirect_count;
1990     return S_OK;
1991 }
1992
1993 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
1994 {
1995     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1996
1997     TRACE("(%p)->(%p)\n", This, string);
1998
1999     return dispex_to_string(&This->dispex, string);
2000 }
2001
2002 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
2003 {
2004     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
2005     FIXME("(%p)->(%p)\n", This, p);
2006     return E_NOTIMPL;
2007 }
2008
2009 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
2010     HTMLPerformanceNavigation_QueryInterface,
2011     HTMLPerformanceNavigation_AddRef,
2012     HTMLPerformanceNavigation_Release,
2013     HTMLPerformanceNavigation_GetTypeInfoCount,
2014     HTMLPerformanceNavigation_GetTypeInfo,
2015     HTMLPerformanceNavigation_GetIDsOfNames,
2016     HTMLPerformanceNavigation_Invoke,
2017     HTMLPerformanceNavigation_get_type,
2018     HTMLPerformanceNavigation_get_redirectCount,
2019     HTMLPerformanceNavigation_toString,
2020     HTMLPerformanceNavigation_toJSON
2021 };
2022
2023 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
2024     IHTMLPerformanceNavigation_tid,
2025     0
2026 };
2027 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
2028     L"PerformanceNavigation",
2029     NULL,
2030     IHTMLPerformanceNavigation_tid,
2031     HTMLPerformanceNavigation_iface_tids
2032 };
2033
2034 typedef struct {
2035     DispatchEx dispex;
2036     IHTMLPerformance IHTMLPerformance_iface;
2037
2038     LONG ref;
2039
2040     IHTMLPerformanceNavigation *navigation;
2041     HTMLPerformanceTiming *timing;
2042 } HTMLPerformance;
2043
2044 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
2045 {
2046     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
2047 }
2048
2049 static HRESULT WINAPI HTMLPerformance_QueryInterface(IHTMLPerformance *iface, REFIID riid, void **ppv)
2050 {
2051     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2052
2053     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2054
2055     if(IsEqualGUID(&IID_IUnknown, riid)) {
2056         *ppv = &This->IHTMLPerformance_iface;
2057     }else if(IsEqualGUID(&IID_IHTMLPerformance, riid)) {
2058         *ppv = &This->IHTMLPerformance_iface;
2059     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2060         return *ppv ? S_OK : E_NOINTERFACE;
2061     }else {
2062         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2063         *ppv = NULL;
2064         return E_NOINTERFACE;
2065     }
2066
2067     IUnknown_AddRef((IUnknown*)*ppv);
2068     return S_OK;
2069 }
2070
2071 static ULONG WINAPI HTMLPerformance_AddRef(IHTMLPerformance *iface)
2072 {
2073     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2074     LONG ref = InterlockedIncrement(&This->ref);
2075
2076     TRACE("(%p) ref=%ld\n", This, ref);
2077
2078     return ref;
2079 }
2080
2081 static ULONG WINAPI HTMLPerformance_Release(IHTMLPerformance *iface)
2082 {
2083     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2084     LONG ref = InterlockedDecrement(&This->ref);
2085
2086     TRACE("(%p) ref=%ld\n", This, ref);
2087
2088     if(!ref) {
2089         IHTMLPerformanceTiming_Release(&This->timing->IHTMLPerformanceTiming_iface);
2090         if(This->navigation)
2091             IHTMLPerformanceNavigation_Release(This->navigation);
2092         release_dispex(&This->dispex);
2093         free(This);
2094     }
2095
2096     return ref;
2097 }
2098
2099 static HRESULT WINAPI HTMLPerformance_GetTypeInfoCount(IHTMLPerformance *iface, UINT *pctinfo)
2100 {
2101     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2102     FIXME("(%p)->(%p)\n", This, pctinfo);
2103     return E_NOTIMPL;
2104 }
2105
2106 static HRESULT WINAPI HTMLPerformance_GetTypeInfo(IHTMLPerformance *iface, UINT iTInfo,
2107                                                   LCID lcid, ITypeInfo **ppTInfo)
2108 {
2109     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2110
2111     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2112 }
2113
2114 static HRESULT WINAPI HTMLPerformance_GetIDsOfNames(IHTMLPerformance *iface, REFIID riid,
2115                                                     LPOLESTR *rgszNames, UINT cNames,
2116                                                     LCID lcid, DISPID *rgDispId)
2117 {
2118     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2119
2120     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2121             lcid, rgDispId);
2122 }
2123
2124 static HRESULT WINAPI HTMLPerformance_Invoke(IHTMLPerformance *iface, DISPID dispIdMember,
2125                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2126                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2127 {
2128     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2129
2130     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2131             pDispParams, pVarResult, pExcepInfo, puArgErr);
2132 }
2133
2134 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
2135                                                      IHTMLPerformanceNavigation **p)
2136 {
2137     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2138
2139     TRACE("(%p)->(%p)\n", This, p);
2140
2141     if(!This->navigation) {
2142         HTMLPerformanceNavigation *navigation;
2143
2144         navigation = calloc(1, sizeof(*navigation));
2145         if(!navigation)
2146             return E_OUTOFMEMORY;
2147
2148         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
2149         navigation->ref = 1;
2150         navigation->timing = This->timing;
2151         IHTMLPerformanceTiming_AddRef(&This->timing->IHTMLPerformanceTiming_iface);
2152
2153         init_dispatch(&navigation->dispex, (IUnknown*)&navigation->IHTMLPerformanceNavigation_iface,
2154                       &HTMLPerformanceNavigation_dispex, dispex_compat_mode(&This->dispex));
2155
2156         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
2157     }
2158
2159     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
2160     return S_OK;
2161 }
2162
2163 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
2164 {
2165     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2166
2167     TRACE("(%p)->(%p)\n", This, p);
2168
2169     IHTMLPerformanceTiming_AddRef(*p = &This->timing->IHTMLPerformanceTiming_iface);
2170     return S_OK;
2171 }
2172
2173 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
2174 {
2175     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2176
2177     TRACE("(%p)->(%p)\n", This, string);
2178
2179     return dispex_to_string(&This->dispex, string);
2180 }
2181
2182 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
2183 {
2184     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
2185     FIXME("(%p)->(%p)\n", This, var);
2186     return E_NOTIMPL;
2187 }
2188
2189 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
2190     HTMLPerformance_QueryInterface,
2191     HTMLPerformance_AddRef,
2192     HTMLPerformance_Release,
2193     HTMLPerformance_GetTypeInfoCount,
2194     HTMLPerformance_GetTypeInfo,
2195     HTMLPerformance_GetIDsOfNames,
2196     HTMLPerformance_Invoke,
2197     HTMLPerformance_get_navigation,
2198     HTMLPerformance_get_timing,
2199     HTMLPerformance_toString,
2200     HTMLPerformance_toJSON
2201 };
2202
2203 static const tid_t HTMLPerformance_iface_tids[] = {
2204     IHTMLPerformance_tid,
2205     0
2206 };
2207 static dispex_static_data_t HTMLPerformance_dispex = {
2208     L"Performance",
2209     NULL,
2210     IHTMLPerformance_tid,
2211     HTMLPerformance_iface_tids
2212 };
2213
2214 HRESULT create_performance(HTMLInnerWindow *window, IHTMLPerformance **ret)
2215 {
2216     compat_mode_t compat_mode = dispex_compat_mode(&window->event_target.dispex);
2217     HTMLPerformance *performance;
2218
2219     performance = calloc(1, sizeof(*performance));
2220     if(!performance)
2221         return E_OUTOFMEMORY;
2222
2223     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
2224     performance->ref = 1;
2225
2226     init_dispatch(&performance->dispex, (IUnknown*)&performance->IHTMLPerformance_iface,
2227                   &HTMLPerformance_dispex, compat_mode);
2228
2229     performance->timing = window->performance_timing;
2230     IHTMLPerformanceTiming_AddRef(&performance->timing->IHTMLPerformanceTiming_iface);
2231
2232     init_dispatch(&performance->timing->dispex, (IUnknown*)&performance->timing->IHTMLPerformanceTiming_iface,
2233                   &HTMLPerformanceTiming_dispex, compat_mode);
2234
2235     *ret = &performance->IHTMLPerformance_iface;
2236     return S_OK;
2237 }
2238
2239 typedef struct {
2240     DispatchEx dispex;
2241     IHTMLNamespaceCollection IHTMLNamespaceCollection_iface;
2242
2243     LONG ref;
2244 } HTMLNamespaceCollection;
2245
2246 static inline HTMLNamespaceCollection *impl_from_IHTMLNamespaceCollection(IHTMLNamespaceCollection *iface)
2247 {
2248     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, IHTMLNamespaceCollection_iface);
2249 }
2250
2251 static HRESULT WINAPI HTMLNamespaceCollection_QueryInterface(IHTMLNamespaceCollection *iface, REFIID riid, void **ppv)
2252 {
2253     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2254
2255     TRACE("(%p)->(%s %p)\n", This, debugstr_mshtml_guid(riid), ppv);
2256
2257     if(IsEqualGUID(&IID_IUnknown, riid)) {
2258         *ppv = &This->IHTMLNamespaceCollection_iface;
2259     }else if(IsEqualGUID(&IID_IHTMLNamespaceCollection, riid)) {
2260         *ppv = &This->IHTMLNamespaceCollection_iface;
2261     }else if(dispex_query_interface(&This->dispex, riid, ppv)) {
2262         return *ppv ? S_OK : E_NOINTERFACE;
2263     }else {
2264         WARN("Unsupported interface %s\n", debugstr_mshtml_guid(riid));
2265         *ppv = NULL;
2266         return E_NOINTERFACE;
2267     }
2268
2269     IUnknown_AddRef((IUnknown*)*ppv);
2270     return S_OK;
2271 }
2272
2273 static ULONG WINAPI HTMLNamespaceCollection_AddRef(IHTMLNamespaceCollection *iface)
2274 {
2275     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2276     LONG ref = InterlockedIncrement(&This->ref);
2277
2278     TRACE("(%p) ref=%ld\n", This, ref);
2279
2280     return ref;
2281 }
2282
2283 static ULONG WINAPI HTMLNamespaceCollection_Release(IHTMLNamespaceCollection *iface)
2284 {
2285     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2286     LONG ref = InterlockedDecrement(&This->ref);
2287
2288     TRACE("(%p) ref=%ld\n", This, ref);
2289
2290     if(!ref) {
2291         release_dispex(&This->dispex);
2292         free(This);
2293     }
2294
2295     return ref;
2296 }
2297
2298 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfoCount(IHTMLNamespaceCollection *iface, UINT *pctinfo)
2299 {
2300     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2301     FIXME("(%p)->(%p)\n", This, pctinfo);
2302     return E_NOTIMPL;
2303 }
2304
2305 static HRESULT WINAPI HTMLNamespaceCollection_GetTypeInfo(IHTMLNamespaceCollection *iface, UINT iTInfo,
2306                                                   LCID lcid, ITypeInfo **ppTInfo)
2307 {
2308     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2309
2310     return IDispatchEx_GetTypeInfo(&This->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2311 }
2312
2313 static HRESULT WINAPI HTMLNamespaceCollection_GetIDsOfNames(IHTMLNamespaceCollection *iface, REFIID riid,
2314                                                     LPOLESTR *rgszNames, UINT cNames,
2315                                                     LCID lcid, DISPID *rgDispId)
2316 {
2317     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2318
2319     return IDispatchEx_GetIDsOfNames(&This->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2320             lcid, rgDispId);
2321 }
2322
2323 static HRESULT WINAPI HTMLNamespaceCollection_Invoke(IHTMLNamespaceCollection *iface, DISPID dispIdMember,
2324                             REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2325                             VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2326 {
2327     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2328
2329     return IDispatchEx_Invoke(&This->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2330             pDispParams, pVarResult, pExcepInfo, puArgErr);
2331 }
2332
2333 static HRESULT WINAPI HTMLNamespaceCollection_get_length(IHTMLNamespaceCollection *iface, LONG *p)
2334 {
2335     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2336     FIXME("(%p)->(%p) returning 0\n", This, p);
2337     *p = 0;
2338     return S_OK;
2339 }
2340
2341 static HRESULT WINAPI HTMLNamespaceCollection_item(IHTMLNamespaceCollection *iface, VARIANT index, IDispatch **p)
2342 {
2343     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2344     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(&index), p);
2345     return E_NOTIMPL;
2346 }
2347
2348 static HRESULT WINAPI HTMLNamespaceCollection_add(IHTMLNamespaceCollection *iface, BSTR namespace, BSTR urn,
2349                                                   VARIANT implementation_url, IDispatch **p)
2350 {
2351     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
2352     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(namespace), debugstr_w(urn), debugstr_variant(&implementation_url), p);
2353     return E_NOTIMPL;
2354 }
2355
2356 static const IHTMLNamespaceCollectionVtbl HTMLNamespaceCollectionVtbl = {
2357     HTMLNamespaceCollection_QueryInterface,
2358     HTMLNamespaceCollection_AddRef,
2359     HTMLNamespaceCollection_Release,
2360     HTMLNamespaceCollection_GetTypeInfoCount,
2361     HTMLNamespaceCollection_GetTypeInfo,
2362     HTMLNamespaceCollection_GetIDsOfNames,
2363     HTMLNamespaceCollection_Invoke,
2364     HTMLNamespaceCollection_get_length,
2365     HTMLNamespaceCollection_item,
2366     HTMLNamespaceCollection_add
2367 };
2368
2369 static const tid_t HTMLNamespaceCollection_iface_tids[] = {
2370     IHTMLNamespaceCollection_tid,
2371     0
2372 };
2373 static dispex_static_data_t HTMLNamespaceCollection_dispex = {
2374     L"MSNamespaceInfoCollection",
2375     NULL,
2376     DispHTMLNamespaceCollection_tid,
2377     HTMLNamespaceCollection_iface_tids
2378 };
2379
2380 HRESULT create_namespace_collection(compat_mode_t compat_mode, IHTMLNamespaceCollection **ret)
2381 {
2382     HTMLNamespaceCollection *namespaces;
2383
2384     if (!(namespaces = calloc(1, sizeof(*namespaces))))
2385         return E_OUTOFMEMORY;
2386
2387     namespaces->IHTMLNamespaceCollection_iface.lpVtbl = &HTMLNamespaceCollectionVtbl;
2388     namespaces->ref = 1;
2389     init_dispatch(&namespaces->dispex, (IUnknown*)&namespaces->IHTMLNamespaceCollection_iface,
2390                   &HTMLNamespaceCollection_dispex, compat_mode);
2391     *ret = &namespaces->IHTMLNamespaceCollection_iface;
2392     return S_OK;
2393 }
2394
2395 struct console {
2396     DispatchEx dispex;
2397     IWineMSHTMLConsole IWineMSHTMLConsole_iface;
2398     LONG ref;
2399 };
2400
2401 static inline struct console *impl_from_IWineMSHTMLConsole(IWineMSHTMLConsole *iface)
2402 {
2403     return CONTAINING_RECORD(iface, struct console, IWineMSHTMLConsole_iface);
2404 }
2405
2406 static HRESULT WINAPI console_QueryInterface(IWineMSHTMLConsole *iface, REFIID riid, void **ppv)
2407 {
2408     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2409
2410     TRACE("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2411
2412     if(IsEqualGUID(&IID_IUnknown, riid)) {
2413         *ppv = &console->IWineMSHTMLConsole_iface;
2414     }else if(IsEqualGUID(&IID_IWineMSHTMLConsole, riid)) {
2415         *ppv = &console->IWineMSHTMLConsole_iface;
2416     }else if(dispex_query_interface(&console->dispex, riid, ppv)) {
2417         return *ppv ? S_OK : E_NOINTERFACE;
2418     }else {
2419         WARN("(%p)->(%s %p)\n", console, debugstr_mshtml_guid(riid), ppv);
2420         *ppv = NULL;
2421         return E_NOINTERFACE;
2422     }
2423
2424     IUnknown_AddRef((IUnknown*)*ppv);
2425     return S_OK;
2426 }
2427
2428 static ULONG WINAPI console_AddRef(IWineMSHTMLConsole *iface)
2429 {
2430     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2431     LONG ref = InterlockedIncrement(&console->ref);
2432
2433     TRACE("(%p) ref=%ld\n", console, ref);
2434
2435     return ref;
2436 }
2437
2438 static ULONG WINAPI console_Release(IWineMSHTMLConsole *iface)
2439 {
2440     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2441     LONG ref = InterlockedDecrement(&console->ref);
2442
2443     TRACE("(%p) ref=%ld\n", console, ref);
2444
2445     if(!ref) {
2446         release_dispex(&console->dispex);
2447         free(console);
2448     }
2449
2450     return ref;
2451 }
2452
2453 static HRESULT WINAPI console_GetTypeInfoCount(IWineMSHTMLConsole *iface, UINT *pctinfo)
2454 {
2455     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2456     FIXME("(%p)->(%p)\n", console, pctinfo);
2457     return E_NOTIMPL;
2458 }
2459
2460 static HRESULT WINAPI console_GetTypeInfo(IWineMSHTMLConsole *iface, UINT iTInfo,
2461         LCID lcid, ITypeInfo **ppTInfo)
2462 {
2463     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2464
2465     return IDispatchEx_GetTypeInfo(&console->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2466 }
2467
2468 static HRESULT WINAPI console_GetIDsOfNames(IWineMSHTMLConsole *iface, REFIID riid,
2469         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2470 {
2471     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2472
2473     return IDispatchEx_GetIDsOfNames(&console->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2474             lcid, rgDispId);
2475 }
2476
2477 static HRESULT WINAPI console_Invoke(IWineMSHTMLConsole *iface, DISPID dispIdMember,
2478         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2479         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2480 {
2481     struct console *console = impl_from_IWineMSHTMLConsole(iface);
2482
2483     return IDispatchEx_Invoke(&console->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2484             pDispParams, pVarResult, pExcepInfo, puArgErr);
2485 }
2486
2487 static HRESULT WINAPI console_assert(IWineMSHTMLConsole *iface, VARIANT_BOOL *assertion, VARIANT *vararg_start)
2488 {
2489     FIXME("iface %p, assertion %p, vararg_start %p stub.\n", iface, assertion, vararg_start);
2490
2491     return S_OK;
2492 }
2493
2494 static HRESULT WINAPI console_clear(IWineMSHTMLConsole *iface)
2495 {
2496     FIXME("iface %p stub.\n", iface);
2497
2498     return S_OK;
2499 }
2500
2501 static HRESULT WINAPI console_count(IWineMSHTMLConsole *iface, VARIANT *label)
2502 {
2503     FIXME("iface %p, label %p stub.\n", iface, label);
2504
2505     return S_OK;
2506 }
2507
2508 static HRESULT WINAPI console_debug(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2509 {
2510     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2511
2512     return S_OK;
2513 }
2514
2515 static HRESULT WINAPI console_dir(IWineMSHTMLConsole *iface, VARIANT *object)
2516 {
2517     FIXME("iface %p, object %p stub.\n", iface, object);
2518
2519     return S_OK;
2520 }
2521
2522 static HRESULT WINAPI console_dirxml(IWineMSHTMLConsole *iface, VARIANT *object)
2523 {
2524     FIXME("iface %p, object %p stub.\n", iface, object);
2525
2526     return S_OK;
2527 }
2528
2529 static HRESULT WINAPI console_error(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2530 {
2531     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2532
2533     return S_OK;
2534 }
2535
2536 static HRESULT WINAPI console_group(IWineMSHTMLConsole *iface, VARIANT *label)
2537 {
2538     FIXME("iface %p, label %p stub.\n", iface, label);
2539
2540     return S_OK;
2541 }
2542
2543 static HRESULT WINAPI console_group_collapsed(IWineMSHTMLConsole *iface, VARIANT *label)
2544 {
2545     FIXME("iface %p, label %p stub.\n", iface, label);
2546
2547     return S_OK;
2548 }
2549
2550 static HRESULT WINAPI console_group_end(IWineMSHTMLConsole *iface)
2551 {
2552     FIXME("iface %p, stub.\n", iface);
2553
2554     return S_OK;
2555 }
2556
2557 static HRESULT WINAPI console_info(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2558 {
2559     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2560
2561     return S_OK;
2562 }
2563
2564 static HRESULT WINAPI console_log(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2565 {
2566     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2567
2568     return S_OK;
2569 }
2570
2571 static HRESULT WINAPI console_time(IWineMSHTMLConsole *iface, VARIANT *label)
2572 {
2573     FIXME("iface %p, label %p stub.\n", iface, label);
2574
2575     return S_OK;
2576 }
2577
2578 static HRESULT WINAPI console_time_end(IWineMSHTMLConsole *iface, VARIANT *label)
2579 {
2580     FIXME("iface %p, label %p stub.\n", iface, label);
2581
2582     return S_OK;
2583 }
2584
2585 static HRESULT WINAPI console_trace(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2586 {
2587     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2588
2589     return S_OK;
2590 }
2591
2592 static HRESULT WINAPI console_warn(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2593 {
2594     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2595
2596     return S_OK;
2597 }
2598
2599 static const IWineMSHTMLConsoleVtbl WineMSHTMLConsoleVtbl = {
2600     console_QueryInterface,
2601     console_AddRef,
2602     console_Release,
2603     console_GetTypeInfoCount,
2604     console_GetTypeInfo,
2605     console_GetIDsOfNames,
2606     console_Invoke,
2607     console_assert,
2608     console_clear,
2609     console_count,
2610     console_debug,
2611     console_dir,
2612     console_dirxml,
2613     console_error,
2614     console_group,
2615     console_group_collapsed,
2616     console_group_end,
2617     console_info,
2618     console_log,
2619     console_time,
2620     console_time_end,
2621     console_trace,
2622     console_warn,
2623 };
2624
2625 static const tid_t console_iface_tids[] = {
2626     IWineMSHTMLConsole_tid,
2627     0
2628 };
2629 static dispex_static_data_t console_dispex = {
2630     L"Console",
2631     NULL,
2632     IWineMSHTMLConsole_tid,
2633     console_iface_tids
2634 };
2635
2636 void create_console(compat_mode_t compat_mode, IWineMSHTMLConsole **ret)
2637 {
2638     struct console *obj;
2639
2640     obj = calloc(1, sizeof(*obj));
2641     if(!obj)
2642     {
2643         ERR("No memory.\n");
2644         return;
2645     }
2646
2647     obj->IWineMSHTMLConsole_iface.lpVtbl = &WineMSHTMLConsoleVtbl;
2648     obj->ref = 1;
2649     init_dispatch(&obj->dispex, (IUnknown*)&obj->IWineMSHTMLConsole_iface, &console_dispex, compat_mode);
2650
2651     *ret = &obj->IWineMSHTMLConsole_iface;
2652 }
2653
2654 struct media_query_list_listener {
2655     struct list entry;
2656     IDispatch *function;
2657 };
2658
2659 struct media_query_list_callback;
2660 struct media_query_list {
2661     DispatchEx dispex;
2662     IWineMSHTMLMediaQueryList IWineMSHTMLMediaQueryList_iface;
2663     LONG ref;
2664     nsIDOMMediaQueryList *nsquerylist;
2665     struct media_query_list_callback *callback;
2666     struct list listeners;
2667 };
2668
2669 struct media_query_list_callback {
2670     nsIDOMMediaQueryListListener nsIDOMMediaQueryListListener_iface;
2671     struct media_query_list *media_query_list;
2672     LONG ref;
2673 };
2674
2675 static inline struct media_query_list *impl_from_IWineMSHTMLMediaQueryList(IWineMSHTMLMediaQueryList *iface)
2676 {
2677     return CONTAINING_RECORD(iface, struct media_query_list, IWineMSHTMLMediaQueryList_iface);
2678 }
2679
2680 static HRESULT WINAPI media_query_list_QueryInterface(IWineMSHTMLMediaQueryList *iface, REFIID riid, void **ppv)
2681 {
2682     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2683
2684     TRACE("(%p)->(%s %p)\n", media_query_list, debugstr_mshtml_guid(riid), ppv);
2685
2686     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IWineMSHTMLMediaQueryList, riid)) {
2687         *ppv = &media_query_list->IWineMSHTMLMediaQueryList_iface;
2688     }else if(dispex_query_interface(&media_query_list->dispex, riid, ppv)) {
2689         return *ppv ? S_OK : E_NOINTERFACE;
2690     }else {
2691         *ppv = NULL;
2692         return E_NOINTERFACE;
2693     }
2694
2695     IUnknown_AddRef((IUnknown*)*ppv);
2696     return S_OK;
2697 }
2698
2699 static ULONG WINAPI media_query_list_AddRef(IWineMSHTMLMediaQueryList *iface)
2700 {
2701     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2702     LONG ref = InterlockedIncrement(&media_query_list->ref);
2703
2704     TRACE("(%p) ref=%ld\n", media_query_list, ref);
2705
2706     return ref;
2707 }
2708
2709 static ULONG WINAPI media_query_list_Release(IWineMSHTMLMediaQueryList *iface)
2710 {
2711     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2712     LONG ref = InterlockedDecrement(&media_query_list->ref);
2713     struct media_query_list_listener *listener, *listener2;
2714
2715     TRACE("(%p) ref=%ld\n", media_query_list, ref);
2716
2717     if(!ref) {
2718         media_query_list->callback->media_query_list = NULL;
2719         LIST_FOR_EACH_ENTRY_SAFE(listener, listener2, &media_query_list->listeners, struct media_query_list_listener, entry) {
2720             IDispatch_Release(listener->function);
2721             free(listener);
2722         }
2723         nsIDOMMediaQueryListListener_Release(&media_query_list->callback->nsIDOMMediaQueryListListener_iface);
2724         nsIDOMMediaQueryList_Release(media_query_list->nsquerylist);
2725         release_dispex(&media_query_list->dispex);
2726         free(media_query_list);
2727     }
2728
2729     return ref;
2730 }
2731
2732 static HRESULT WINAPI media_query_list_GetTypeInfoCount(IWineMSHTMLMediaQueryList *iface, UINT *pctinfo)
2733 {
2734     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2735
2736     TRACE("(%p)->(%p)\n", media_query_list, pctinfo);
2737
2738     return IDispatchEx_GetTypeInfoCount(&media_query_list->dispex.IDispatchEx_iface, pctinfo);
2739 }
2740
2741 static HRESULT WINAPI media_query_list_GetTypeInfo(IWineMSHTMLMediaQueryList *iface, UINT iTInfo,
2742         LCID lcid, ITypeInfo **ppTInfo)
2743 {
2744     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2745
2746     return IDispatchEx_GetTypeInfo(&media_query_list->dispex.IDispatchEx_iface, iTInfo, lcid, ppTInfo);
2747 }
2748
2749 static HRESULT WINAPI media_query_list_GetIDsOfNames(IWineMSHTMLMediaQueryList *iface, REFIID riid,
2750         LPOLESTR *rgszNames, UINT cNames, LCID lcid, DISPID *rgDispId)
2751 {
2752     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2753
2754     return IDispatchEx_GetIDsOfNames(&media_query_list->dispex.IDispatchEx_iface, riid, rgszNames, cNames,
2755             lcid, rgDispId);
2756 }
2757
2758 static HRESULT WINAPI media_query_list_Invoke(IWineMSHTMLMediaQueryList *iface, DISPID dispIdMember,
2759         REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS *pDispParams,
2760         VARIANT *pVarResult, EXCEPINFO *pExcepInfo, UINT *puArgErr)
2761 {
2762     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2763
2764     return IDispatchEx_Invoke(&media_query_list->dispex.IDispatchEx_iface, dispIdMember, riid, lcid, wFlags,
2765             pDispParams, pVarResult, pExcepInfo, puArgErr);
2766 }
2767
2768 static HRESULT WINAPI media_query_list_get_media(IWineMSHTMLMediaQueryList *iface, BSTR *p)
2769 {
2770     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2771     nsAString nsstr;
2772
2773     TRACE("(%p)->(%p)\n", media_query_list, p);
2774
2775     nsAString_InitDepend(&nsstr, NULL);
2776     return return_nsstr(nsIDOMMediaQueryList_GetMedia(media_query_list->nsquerylist, &nsstr), &nsstr, p);
2777 }
2778
2779 static HRESULT WINAPI media_query_list_get_matches(IWineMSHTMLMediaQueryList *iface, VARIANT_BOOL *p)
2780 {
2781     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2782     nsresult nsres;
2783     cpp_bool b;
2784
2785     TRACE("(%p)->(%p)\n", media_query_list, p);
2786
2787     nsres = nsIDOMMediaQueryList_GetMatches(media_query_list->nsquerylist, &b);
2788     if(NS_FAILED(nsres))
2789         return map_nsresult(nsres);
2790     *p = b ? VARIANT_TRUE : VARIANT_FALSE;
2791     return S_OK;
2792 }
2793
2794 static HRESULT WINAPI media_query_list_addListener(IWineMSHTMLMediaQueryList *iface, VARIANT *listener)
2795 {
2796     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2797     struct media_query_list_listener *entry;
2798
2799     TRACE("(%p)->(%s)\n", media_query_list, debugstr_variant(listener));
2800
2801     if(V_VT(listener) != VT_DISPATCH || !V_DISPATCH(listener))
2802         return S_OK;
2803
2804     LIST_FOR_EACH_ENTRY(entry, &media_query_list->listeners, struct media_query_list_listener, entry)
2805         if(entry->function == V_DISPATCH(listener))
2806             return S_OK;
2807
2808     if(!(entry = malloc(sizeof(*entry))))
2809         return E_OUTOFMEMORY;
2810     entry->function = V_DISPATCH(listener);
2811     IDispatch_AddRef(V_DISPATCH(listener));
2812
2813     list_add_tail(&media_query_list->listeners, &entry->entry);
2814     return S_OK;
2815 }
2816
2817 static HRESULT WINAPI media_query_list_removeListener(IWineMSHTMLMediaQueryList *iface, VARIANT *listener)
2818 {
2819     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2820     struct media_query_list_listener *entry;
2821
2822     TRACE("(%p)->(%s)\n", media_query_list, debugstr_variant(listener));
2823
2824     if(V_VT(listener) != VT_DISPATCH || !V_DISPATCH(listener))
2825         return S_OK;
2826
2827     LIST_FOR_EACH_ENTRY(entry, &media_query_list->listeners, struct media_query_list_listener, entry) {
2828         if(entry->function == V_DISPATCH(listener)) {
2829             list_remove(&entry->entry);
2830             IDispatch_Release(entry->function);
2831             free(entry);
2832             break;
2833         }
2834     }
2835
2836     return S_OK;
2837 }
2838
2839 static const IWineMSHTMLMediaQueryListVtbl media_query_list_vtbl = {
2840     media_query_list_QueryInterface,
2841     media_query_list_AddRef,
2842     media_query_list_Release,
2843     media_query_list_GetTypeInfoCount,
2844     media_query_list_GetTypeInfo,
2845     media_query_list_GetIDsOfNames,
2846     media_query_list_Invoke,
2847     media_query_list_get_media,
2848     media_query_list_get_matches,
2849     media_query_list_addListener,
2850     media_query_list_removeListener
2851 };
2852
2853 static inline struct media_query_list_callback *impl_from_nsIDOMMediaQueryListListener(nsIDOMMediaQueryListListener *iface)
2854 {
2855     return CONTAINING_RECORD(iface, struct media_query_list_callback, nsIDOMMediaQueryListListener_iface);
2856 }
2857
2858 static nsresult NSAPI media_query_list_callback_QueryInterface(nsIDOMMediaQueryListListener *iface,
2859         nsIIDRef riid, void **result)
2860 {
2861     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2862
2863     if(IsEqualGUID(&IID_nsISupports, riid) || IsEqualGUID(&IID_nsIDOMMediaQueryListListener, riid)) {
2864         *result = &callback->nsIDOMMediaQueryListListener_iface;
2865     }else {
2866         *result = NULL;
2867         return NS_NOINTERFACE;
2868     }
2869
2870     nsIDOMMediaQueryListListener_AddRef(&callback->nsIDOMMediaQueryListListener_iface);
2871     return NS_OK;
2872 }
2873
2874 static nsrefcnt NSAPI media_query_list_callback_AddRef(nsIDOMMediaQueryListListener *iface)
2875 {
2876     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2877     LONG ref = InterlockedIncrement(&callback->ref);
2878
2879     TRACE("(%p) ref=%ld\n", callback, ref);
2880
2881     return ref;
2882 }
2883
2884 static nsrefcnt NSAPI media_query_list_callback_Release(nsIDOMMediaQueryListListener *iface)
2885 {
2886     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2887     LONG ref = InterlockedDecrement(&callback->ref);
2888
2889     TRACE("(%p) ref=%ld\n", callback, ref);
2890
2891     if(!ref)
2892         free(callback);
2893     return ref;
2894 }
2895
2896 static nsresult NSAPI media_query_list_callback_HandleChange(nsIDOMMediaQueryListListener *iface, nsIDOMMediaQueryList *mql)
2897 {
2898     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2899     IDispatch *listener_funcs_buf[4], **listener_funcs = listener_funcs_buf;
2900     struct media_query_list *media_query_list = callback->media_query_list;
2901     struct media_query_list_listener *listener;
2902     unsigned cnt, i = 0;
2903     VARIANT args[1], v;
2904     HRESULT hres;
2905
2906     if(!media_query_list)
2907         return NS_OK;
2908
2909     cnt = list_count(&media_query_list->listeners);
2910     if(cnt > ARRAY_SIZE(listener_funcs_buf) && !(listener_funcs = malloc(cnt * sizeof(*listener_funcs))))
2911         return NS_ERROR_OUT_OF_MEMORY;
2912
2913     LIST_FOR_EACH_ENTRY(listener, &media_query_list->listeners, struct media_query_list_listener, entry) {
2914         listener_funcs[i] = listener->function;
2915         IDispatch_AddRef(listener_funcs[i++]);
2916     }
2917
2918     for(i = 0; i < cnt; i++) {
2919         DISPPARAMS dp = { args, NULL, 1, 0 };
2920
2921         V_VT(args) = VT_DISPATCH;
2922         V_DISPATCH(args) = (IDispatch*)&media_query_list->dispex.IDispatchEx_iface;
2923         V_VT(&v) = VT_EMPTY;
2924
2925         TRACE("%p >>>\n", media_query_list);
2926         hres = call_disp_func(listener_funcs[i], &dp, &v);
2927         if(hres == S_OK) {
2928             TRACE("%p <<< %s\n", media_query_list, debugstr_variant(&v));
2929             VariantClear(&v);
2930         }else {
2931             WARN("%p <<< %08lx\n", media_query_list, hres);
2932         }
2933         IDispatch_Release(listener_funcs[i]);
2934     }
2935
2936     if(listener_funcs != listener_funcs_buf)
2937         free(listener_funcs);
2938     return NS_OK;
2939 }
2940
2941 static const nsIDOMMediaQueryListListenerVtbl media_query_list_callback_vtbl = {
2942     media_query_list_callback_QueryInterface,
2943     media_query_list_callback_AddRef,
2944     media_query_list_callback_Release,
2945     media_query_list_callback_HandleChange
2946 };
2947
2948 static const tid_t media_query_list_iface_tids[] = {
2949     IWineMSHTMLMediaQueryList_tid,
2950     0
2951 };
2952 static dispex_static_data_t media_query_list_dispex = {
2953     L"MediaQueryList",
2954     NULL,
2955     IWineMSHTMLMediaQueryList_tid,
2956     media_query_list_iface_tids
2957 };
2958
2959 HRESULT create_media_query_list(HTMLWindow *window, BSTR media_query, IDispatch **ret)
2960 {
2961     struct media_query_list *media_query_list;
2962     nsISupports *nsunk;
2963     nsAString nsstr;
2964     nsresult nsres;
2965
2966     if(!media_query || !media_query[0])
2967         return E_INVALIDARG;
2968
2969     if(!(media_query_list = malloc(sizeof(*media_query_list))))
2970         return E_OUTOFMEMORY;
2971
2972     if(!(media_query_list->callback = malloc(sizeof(*media_query_list->callback)))) {
2973         free(media_query_list);
2974         return E_OUTOFMEMORY;
2975     }
2976     media_query_list->callback->nsIDOMMediaQueryListListener_iface.lpVtbl = &media_query_list_callback_vtbl;
2977     media_query_list->callback->media_query_list = media_query_list;
2978     media_query_list->callback->ref = 1;
2979
2980     nsAString_InitDepend(&nsstr, media_query);
2981     nsres = nsIDOMWindow_MatchMedia(window->outer_window->nswindow, &nsstr, &nsunk);
2982     nsAString_Finish(&nsstr);
2983     if(NS_FAILED(nsres)) {
2984         free(media_query_list->callback);
2985         free(media_query_list);
2986         return map_nsresult(nsres);
2987     }
2988     nsres = nsISupports_QueryInterface(nsunk, &IID_nsIDOMMediaQueryList, (void**)&media_query_list->nsquerylist);
2989     assert(NS_SUCCEEDED(nsres));
2990     nsISupports_Release(nsunk);
2991
2992     nsres = nsIDOMMediaQueryList_SetListener(media_query_list->nsquerylist, &media_query_list->callback->nsIDOMMediaQueryListListener_iface);
2993     assert(NS_SUCCEEDED(nsres));
2994
2995     media_query_list->IWineMSHTMLMediaQueryList_iface.lpVtbl = &media_query_list_vtbl;
2996     media_query_list->ref = 1;
2997     list_init(&media_query_list->listeners);
2998     init_dispatch(&media_query_list->dispex, (IUnknown*)&media_query_list->IWineMSHTMLMediaQueryList_iface,
2999                   &media_query_list_dispex, dispex_compat_mode(&window->inner_window->event_target.dispex));
3000
3001     *ret = (IDispatch*)&media_query_list->IWineMSHTMLMediaQueryList_iface;
3002     return S_OK;
3003 }