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     HTMLPluginsCollection *plugins;
  42     HTMLMimeTypesCollection *mime_types;
  43 } OmNavigator;
  44
  45 typedef struct {
  46     DispatchEx dispex;
  47     IHTMLDOMImplementation IHTMLDOMImplementation_iface;
  48     IHTMLDOMImplementation2 IHTMLDOMImplementation2_iface;
  49
  50     nsIDOMDOMImplementation *implementation;
  51     HTMLDocumentNode *doc;
  52 } HTMLDOMImplementation;
  53
  54 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation(IHTMLDOMImplementation *iface)
  55 {
  56     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation_iface);
  57 }
  58
  59 DISPEX_IDISPATCH_IMPL(HTMLDOMImplementation, IHTMLDOMImplementation,
  60                       impl_from_IHTMLDOMImplementation(iface)->dispex)
  61
  62 static HRESULT WINAPI HTMLDOMImplementation_hasFeature(IHTMLDOMImplementation *iface, BSTR feature,
  63         VARIANT version, VARIANT_BOOL *pfHasFeature)
  64 {
  65     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation(iface);
  66
  67     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
  68
  69     *pfHasFeature = VARIANT_FALSE;
  70     return S_OK;
  71 }
  72
  73 static const IHTMLDOMImplementationVtbl HTMLDOMImplementationVtbl = {
  74     HTMLDOMImplementation_QueryInterface,
  75     HTMLDOMImplementation_AddRef,
  76     HTMLDOMImplementation_Release,
  77     HTMLDOMImplementation_GetTypeInfoCount,
  78     HTMLDOMImplementation_GetTypeInfo,
  79     HTMLDOMImplementation_GetIDsOfNames,
  80     HTMLDOMImplementation_Invoke,
  81     HTMLDOMImplementation_hasFeature
  82 };
  83
  84 static inline HTMLDOMImplementation *impl_from_IHTMLDOMImplementation2(IHTMLDOMImplementation2 *iface)
  85 {
  86     return CONTAINING_RECORD(iface, HTMLDOMImplementation, IHTMLDOMImplementation2_iface);
  87 }
  88
  89 DISPEX_IDISPATCH_IMPL(HTMLDOMImplementation2, IHTMLDOMImplementation2,
  90                       impl_from_IHTMLDOMImplementation2(iface)->dispex)
  91
  92 static HRESULT WINAPI HTMLDOMImplementation2_createDocumentType(IHTMLDOMImplementation2 *iface, BSTR name,
  93         VARIANT *public_id, VARIANT *system_id, IDOMDocumentType **new_type)
  94 {
  95     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
  96     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(name), debugstr_variant(public_id),
  97           debugstr_variant(system_id), new_type);
  98     return E_NOTIMPL;
  99 }
 100
 101 static HRESULT WINAPI HTMLDOMImplementation2_createDocument(IHTMLDOMImplementation2 *iface, VARIANT *ns,
 102         VARIANT *tag_name, IDOMDocumentType *document_type, IHTMLDocument7 **new_document)
 103 {
 104     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 105     FIXME("(%p)->(%s %s %p %p)\n", This, debugstr_variant(ns), debugstr_variant(tag_name),
 106           document_type, new_document);
 107     return E_NOTIMPL;
 108 }
 109
 110 static HRESULT WINAPI HTMLDOMImplementation2_createHTMLDocument(IHTMLDOMImplementation2 *iface, BSTR title,
 111         IHTMLDocument7 **new_document)
 112 {
 113     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 114     HTMLDocumentNode *new_document_node;
 115     nsIDOMDocument *doc;
 116     nsAString title_str;
 117     nsresult nsres;
 118     HRESULT hres;
 119
 120     FIXME("(%p)->(%s %p)\n", This, debugstr_w(title), new_document);
 121
 122     if(!This->doc || !This->doc->browser)
 123         return E_UNEXPECTED;
 124
 125     nsAString_InitDepend(&title_str, title);
 126     nsres = nsIDOMDOMImplementation_CreateHTMLDocument(This->implementation, &title_str, &doc);
 127     nsAString_Finish(&title_str);
 128     if(NS_FAILED(nsres)) {
 129         ERR("CreateHTMLDocument failed: %08lx\n", nsres);
 130         return E_FAIL;
 131     }
 132
 133     hres = create_document_node(doc, This->doc->browser, NULL, This->doc->script_global,
 134                                 dispex_compat_mode(&This->dispex), &new_document_node);
 135     nsIDOMDocument_Release(doc);
 136     if(FAILED(hres))
 137         return hres;
 138
 139     *new_document = &new_document_node->IHTMLDocument7_iface;
 140     return S_OK;
 141 }
 142
 143 static HRESULT WINAPI HTMLDOMImplementation2_hasFeature(IHTMLDOMImplementation2 *iface, BSTR feature,
 144         VARIANT version, VARIANT_BOOL *pfHasFeature)
 145 {
 146     HTMLDOMImplementation *This = impl_from_IHTMLDOMImplementation2(iface);
 147
 148     FIXME("(%p)->(%s %s %p) returning false\n", This, debugstr_w(feature), debugstr_variant(&version), pfHasFeature);
 149
 150     *pfHasFeature = VARIANT_FALSE;
 151     return S_OK;
 152 }
 153
 154 static const IHTMLDOMImplementation2Vtbl HTMLDOMImplementation2Vtbl = {
 155     HTMLDOMImplementation2_QueryInterface,
 156     HTMLDOMImplementation2_AddRef,
 157     HTMLDOMImplementation2_Release,
 158     HTMLDOMImplementation2_GetTypeInfoCount,
 159     HTMLDOMImplementation2_GetTypeInfo,
 160     HTMLDOMImplementation2_GetIDsOfNames,
 161     HTMLDOMImplementation2_Invoke,
 162     HTMLDOMImplementation2_createDocumentType,
 163     HTMLDOMImplementation2_createDocument,
 164     HTMLDOMImplementation2_createHTMLDocument,
 165     HTMLDOMImplementation2_hasFeature
 166 };
 167
 168 static inline HTMLDOMImplementation *HTMLDOMImplementation_from_DispatchEx(DispatchEx *iface)
 169 {
 170     return CONTAINING_RECORD(iface, HTMLDOMImplementation, dispex);
 171 }
 172
 173 static void *HTMLDOMImplementation_query_interface(DispatchEx *dispex, REFIID riid)
 174 {
 175     HTMLDOMImplementation *This = HTMLDOMImplementation_from_DispatchEx(dispex);
 176
 177     if(IsEqualGUID(&IID_IHTMLDOMImplementation, riid))
 178         return &This->IHTMLDOMImplementation_iface;
 179     if(IsEqualGUID(&IID_IHTMLDOMImplementation2, riid))
 180         return &This->IHTMLDOMImplementation2_iface;
 181
 182     return NULL;
 183 }
 184
 185 static void HTMLDOMImplementation_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
 186 {
 187     HTMLDOMImplementation *This = HTMLDOMImplementation_from_DispatchEx(dispex);
 188     if(This->implementation)
 189         note_cc_edge((nsISupports*)This->implementation, "implementation", cb);
 190 }
 191
 192 static void HTMLDOMImplementation_unlink(DispatchEx *dispex)
 193 {
 194     HTMLDOMImplementation *This = HTMLDOMImplementation_from_DispatchEx(dispex);
 195     unlink_ref(&This->implementation);
 196 }
 197
 198 static void HTMLDOMImplementation_destructor(DispatchEx *dispex)
 199 {
 200     HTMLDOMImplementation *This = HTMLDOMImplementation_from_DispatchEx(dispex);
 201     assert(!This->doc);
 202     free(This);
 203 }
 204
 205 static const dispex_static_data_vtbl_t HTMLDOMImplementation_dispex_vtbl = {
 206     .query_interface  = HTMLDOMImplementation_query_interface,
 207     .destructor       = HTMLDOMImplementation_destructor,
 208     .traverse         = HTMLDOMImplementation_traverse,
 209     .unlink           = HTMLDOMImplementation_unlink
 210 };
 211
 212 static void HTMLDOMImplementation_init_dispex_info(dispex_data_t *info, compat_mode_t compat_mode)
 213 {
 214     if(compat_mode >= COMPAT_MODE_IE9)
 215         dispex_info_add_interface(info, IHTMLDOMImplementation2_tid, NULL);
 216 }
 217
 218 static const tid_t HTMLDOMImplementation_iface_tids[] = {
 219     IHTMLDOMImplementation_tid,
 220     0
 221 };
 222 static dispex_static_data_t HTMLDOMImplementation_dispex = {
 223     "DOMImplementation",
 224     &HTMLDOMImplementation_dispex_vtbl,
 225     DispHTMLDOMImplementation_tid,
 226     HTMLDOMImplementation_iface_tids,
 227     HTMLDOMImplementation_init_dispex_info
 228 };
 229
 230 HRESULT create_dom_implementation(HTMLDocumentNode *doc_node, IHTMLDOMImplementation **ret)
 231 {
 232     HTMLDOMImplementation *dom_implementation;
 233     nsresult nsres;
 234
 235     if(!doc_node->browser)
 236         return E_UNEXPECTED;
 237
 238     dom_implementation = calloc(1, sizeof(*dom_implementation));
 239     if(!dom_implementation)
 240         return E_OUTOFMEMORY;
 241
 242     dom_implementation->IHTMLDOMImplementation_iface.lpVtbl = &HTMLDOMImplementationVtbl;
 243     dom_implementation->IHTMLDOMImplementation2_iface.lpVtbl = &HTMLDOMImplementation2Vtbl;
 244     dom_implementation->doc = doc_node;
 245
 246     init_dispatch(&dom_implementation->dispex, &HTMLDOMImplementation_dispex, doc_node->script_global, doc_node->document_mode);
 247
 248     nsres = nsIDOMDocument_GetImplementation(doc_node->dom_document, &dom_implementation->implementation);
 249     if(NS_FAILED(nsres)) {
 250         ERR("GetDOMImplementation failed: %08lx\n", nsres);
 251         IHTMLDOMImplementation_Release(&dom_implementation->IHTMLDOMImplementation_iface);
 252         return E_FAIL;
 253     }
 254
 255     *ret = &dom_implementation->IHTMLDOMImplementation_iface;
 256     return S_OK;
 257 }
 258
 259 void detach_dom_implementation(IHTMLDOMImplementation *iface)
 260 {
 261     HTMLDOMImplementation *dom_implementation = impl_from_IHTMLDOMImplementation(iface);
 262     dom_implementation->doc = NULL;
 263 }
 264
 265 typedef struct {
 266     DispatchEx dispex;
 267     IHTMLScreen IHTMLScreen_iface;
 268 } HTMLScreen;
 269
 270 static inline HTMLScreen *impl_from_IHTMLScreen(IHTMLScreen *iface)
 271 {
 272     return CONTAINING_RECORD(iface, HTMLScreen, IHTMLScreen_iface);
 273 }
 274
 275 DISPEX_IDISPATCH_IMPL(HTMLScreen, IHTMLScreen, impl_from_IHTMLScreen(iface)->dispex)
 276
 277 static HRESULT WINAPI HTMLScreen_get_colorDepth(IHTMLScreen *iface, LONG *p)
 278 {
 279     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 280     HDC hdc = GetDC(0);
 281
 282     TRACE("(%p)->(%p)\n", This, p);
 283
 284     *p = GetDeviceCaps(hdc, BITSPIXEL);
 285     ReleaseDC(0, hdc);
 286     return S_OK;
 287 }
 288
 289 static HRESULT WINAPI HTMLScreen_put_bufferDepth(IHTMLScreen *iface, LONG v)
 290 {
 291     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 292     FIXME("(%p)->(%ld)\n", This, v);
 293     return E_NOTIMPL;
 294 }
 295
 296 static HRESULT WINAPI HTMLScreen_get_bufferDepth(IHTMLScreen *iface, LONG *p)
 297 {
 298     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 299     FIXME("(%p)->(%p)\n", This, p);
 300     return E_NOTIMPL;
 301 }
 302
 303 static HRESULT WINAPI HTMLScreen_get_width(IHTMLScreen *iface, LONG *p)
 304 {
 305     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 306
 307     TRACE("(%p)->(%p)\n", This, p);
 308
 309     *p = GetSystemMetrics(SM_CXSCREEN);
 310     return S_OK;
 311 }
 312
 313 static HRESULT WINAPI HTMLScreen_get_height(IHTMLScreen *iface, LONG *p)
 314 {
 315     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 316
 317     TRACE("(%p)->(%p)\n", This, p);
 318
 319     *p = GetSystemMetrics(SM_CYSCREEN);
 320     return S_OK;
 321 }
 322
 323 static HRESULT WINAPI HTMLScreen_put_updateInterval(IHTMLScreen *iface, LONG v)
 324 {
 325     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 326     FIXME("(%p)->(%ld)\n", This, v);
 327     return E_NOTIMPL;
 328 }
 329
 330 static HRESULT WINAPI HTMLScreen_get_updateInterval(IHTMLScreen *iface, LONG *p)
 331 {
 332     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 333     FIXME("(%p)->(%p)\n", This, p);
 334     return E_NOTIMPL;
 335 }
 336
 337 static HRESULT WINAPI HTMLScreen_get_availHeight(IHTMLScreen *iface, LONG *p)
 338 {
 339     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 340     RECT work_area;
 341
 342     TRACE("(%p)->(%p)\n", This, p);
 343
 344     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 345         return E_FAIL;
 346
 347     *p = work_area.bottom-work_area.top;
 348     return S_OK;
 349 }
 350
 351 static HRESULT WINAPI HTMLScreen_get_availWidth(IHTMLScreen *iface, LONG *p)
 352 {
 353     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 354     RECT work_area;
 355
 356     TRACE("(%p)->(%p)\n", This, p);
 357
 358     if(!SystemParametersInfoW(SPI_GETWORKAREA, 0, &work_area, 0))
 359         return E_FAIL;
 360
 361     *p = work_area.right-work_area.left;
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI HTMLScreen_get_fontSmoothingEnabled(IHTMLScreen *iface, VARIANT_BOOL *p)
 366 {
 367     HTMLScreen *This = impl_from_IHTMLScreen(iface);
 368     FIXME("(%p)->(%p)\n", This, p);
 369     return E_NOTIMPL;
 370 }
 371
 372 static const IHTMLScreenVtbl HTMLSreenVtbl = {
 373     HTMLScreen_QueryInterface,
 374     HTMLScreen_AddRef,
 375     HTMLScreen_Release,
 376     HTMLScreen_GetTypeInfoCount,
 377     HTMLScreen_GetTypeInfo,
 378     HTMLScreen_GetIDsOfNames,
 379     HTMLScreen_Invoke,
 380     HTMLScreen_get_colorDepth,
 381     HTMLScreen_put_bufferDepth,
 382     HTMLScreen_get_bufferDepth,
 383     HTMLScreen_get_width,
 384     HTMLScreen_get_height,
 385     HTMLScreen_put_updateInterval,
 386     HTMLScreen_get_updateInterval,
 387     HTMLScreen_get_availHeight,
 388     HTMLScreen_get_availWidth,
 389     HTMLScreen_get_fontSmoothingEnabled
 390 };
 391
 392 static inline HTMLScreen *HTMLScreen_from_DispatchEx(DispatchEx *iface)
 393 {
 394     return CONTAINING_RECORD(iface, HTMLScreen, dispex);
 395 }
 396
 397 static void *HTMLScreen_query_interface(DispatchEx *dispex, REFIID riid)
 398 {
 399     HTMLScreen *This = HTMLScreen_from_DispatchEx(dispex);
 400
 401     if(IsEqualGUID(&IID_IHTMLScreen, riid))
 402         return &This->IHTMLScreen_iface;
 403
 404     return NULL;
 405 }
 406
 407 static void HTMLScreen_destructor(DispatchEx *dispex)
 408 {
 409     HTMLScreen *This = HTMLScreen_from_DispatchEx(dispex);
 410     free(This);
 411 }
 412
 413 static const dispex_static_data_vtbl_t HTMLScreen_dispex_vtbl = {
 414     .query_interface  = HTMLScreen_query_interface,
 415     .destructor       = HTMLScreen_destructor,
 416 };
 417
 418 static const tid_t HTMLScreen_iface_tids[] = {
 419     IHTMLScreen_tid,
 420     0
 421 };
 422 static dispex_static_data_t HTMLScreen_dispex = {
 423     "Screen",
 424     &HTMLScreen_dispex_vtbl,
 425     DispHTMLScreen_tid,
 426     HTMLScreen_iface_tids
 427 };
 428
 429 HRESULT create_html_screen(HTMLInnerWindow *window, IHTMLScreen **ret)
 430 {
 431     HTMLScreen *screen;
 432
 433     screen = calloc(1, sizeof(HTMLScreen));
 434     if(!screen)
 435         return E_OUTOFMEMORY;
 436
 437     screen->IHTMLScreen_iface.lpVtbl = &HTMLSreenVtbl;
 438
 439     init_dispatch(&screen->dispex, &HTMLScreen_dispex, window,
 440                   dispex_compat_mode(&window->event_target.dispex));
 441
 442     *ret = &screen->IHTMLScreen_iface;
 443     return S_OK;
 444 }
 445
 446 static inline OmHistory *impl_from_IOmHistory(IOmHistory *iface)
 447 {
 448     return CONTAINING_RECORD(iface, OmHistory, IOmHistory_iface);
 449 }
 450
 451 DISPEX_IDISPATCH_IMPL(OmHistory, IOmHistory, impl_from_IOmHistory(iface)->dispex)
 452
 453 static HRESULT WINAPI OmHistory_get_length(IOmHistory *iface, short *p)
 454 {
 455     OmHistory *This = impl_from_IOmHistory(iface);
 456     GeckoBrowser *browser = NULL;
 457
 458     TRACE("(%p)->(%p)\n", This, p);
 459
 460     if(This->window->base.outer_window)
 461         browser = This->window->base.outer_window->browser;
 462
 463     *p = browser && browser->doc->travel_log
 464         ? ITravelLog_CountEntries(browser->doc->travel_log, browser->doc->browser_service)
 465         : 0;
 466     return S_OK;
 467 }
 468
 469 static HRESULT WINAPI OmHistory_back(IOmHistory *iface, VARIANT *pvargdistance)
 470 {
 471     OmHistory *This = impl_from_IOmHistory(iface);
 472     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI OmHistory_forward(IOmHistory *iface, VARIANT *pvargdistance)
 477 {
 478     OmHistory *This = impl_from_IOmHistory(iface);
 479     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI OmHistory_go(IOmHistory *iface, VARIANT *pvargdistance)
 484 {
 485     OmHistory *This = impl_from_IOmHistory(iface);
 486     FIXME("(%p)->(%s)\n", This, debugstr_variant(pvargdistance));
 487     return E_NOTIMPL;
 488 }
 489
 490 static const IOmHistoryVtbl OmHistoryVtbl = {
 491     OmHistory_QueryInterface,
 492     OmHistory_AddRef,
 493     OmHistory_Release,
 494     OmHistory_GetTypeInfoCount,
 495     OmHistory_GetTypeInfo,
 496     OmHistory_GetIDsOfNames,
 497     OmHistory_Invoke,
 498     OmHistory_get_length,
 499     OmHistory_back,
 500     OmHistory_forward,
 501     OmHistory_go
 502 };
 503
 504 static inline OmHistory *OmHistory_from_DispatchEx(DispatchEx *iface)
 505 {
 506     return CONTAINING_RECORD(iface, OmHistory, dispex);
 507 }
 508
 509 static void *OmHistory_query_interface(DispatchEx *dispex, REFIID riid)
 510 {
 511     OmHistory *This = OmHistory_from_DispatchEx(dispex);
 512
 513     if(IsEqualGUID(&IID_IOmHistory, riid))
 514         return &This->IOmHistory_iface;
 515
 516     return NULL;
 517 }
 518
 519 static void OmHistory_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
 520 {
 521     OmHistory *This = OmHistory_from_DispatchEx(dispex);
 522
 523     if(This->window)
 524         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
 525 }
 526
 527 static void OmHistory_unlink(DispatchEx *dispex)
 528 {
 529     OmHistory *This = OmHistory_from_DispatchEx(dispex);
 530
 531     if(This->window) {
 532         HTMLInnerWindow *window = This->window;
 533         This->window = NULL;
 534         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
 535     }
 536 }
 537
 538 static void OmHistory_destructor(DispatchEx *dispex)
 539 {
 540     OmHistory *This = OmHistory_from_DispatchEx(dispex);
 541     free(This);
 542 }
 543
 544 static const dispex_static_data_vtbl_t OmHistory_dispex_vtbl = {
 545     .query_interface  = OmHistory_query_interface,
 546     .destructor       = OmHistory_destructor,
 547     .traverse         = OmHistory_traverse,
 548     .unlink           = OmHistory_unlink,
 549 };
 550
 551 static const tid_t OmHistory_iface_tids[] = {
 552     IOmHistory_tid,
 553     0
 554 };
 555 static dispex_static_data_t OmHistory_dispex = {
 556     "History",
 557     &OmHistory_dispex_vtbl,
 558     DispHTMLHistory_tid,
 559     OmHistory_iface_tids
 560 };
 561
 562
 563 HRESULT create_history(HTMLInnerWindow *window, OmHistory **ret)
 564 {
 565     OmHistory *history;
 566
 567     history = calloc(1, sizeof(*history));
 568     if(!history)
 569         return E_OUTOFMEMORY;
 570
 571     init_dispatch(&history->dispex, &OmHistory_dispex, window,
 572                   dispex_compat_mode(&window->event_target.dispex));
 573     history->IOmHistory_iface.lpVtbl = &OmHistoryVtbl;
 574
 575     history->window = window;
 576     IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
 577
 578     *ret = history;
 579     return S_OK;
 580 }
 581
 582 struct HTMLPluginsCollection {
 583     DispatchEx dispex;
 584     IHTMLPluginsCollection IHTMLPluginsCollection_iface;
 585
 586     OmNavigator *navigator;
 587 };
 588
 589 static inline HTMLPluginsCollection *impl_from_IHTMLPluginsCollection(IHTMLPluginsCollection *iface)
 590 {
 591     return CONTAINING_RECORD(iface, HTMLPluginsCollection, IHTMLPluginsCollection_iface);
 592 }
 593
 594 DISPEX_IDISPATCH_IMPL(HTMLPluginsCollection, IHTMLPluginsCollection,
 595                       impl_from_IHTMLPluginsCollection(iface)->dispex)
 596
 597 static HRESULT WINAPI HTMLPluginsCollection_get_length(IHTMLPluginsCollection *iface, LONG *p)
 598 {
 599     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 600
 601     TRACE("(%p)->(%p)\n", This, p);
 602
 603     /* IE always returns 0 here */
 604     *p = 0;
 605     return S_OK;
 606 }
 607
 608 static HRESULT WINAPI HTMLPluginsCollection_refresh(IHTMLPluginsCollection *iface, VARIANT_BOOL reload)
 609 {
 610     HTMLPluginsCollection *This = impl_from_IHTMLPluginsCollection(iface);
 611
 612     TRACE("(%p)->(%x)\n", This, reload);
 613
 614     /* Nothing to do here. */
 615     return S_OK;
 616 }
 617
 618 static const IHTMLPluginsCollectionVtbl HTMLPluginsCollectionVtbl = {
 619     HTMLPluginsCollection_QueryInterface,
 620     HTMLPluginsCollection_AddRef,
 621     HTMLPluginsCollection_Release,
 622     HTMLPluginsCollection_GetTypeInfoCount,
 623     HTMLPluginsCollection_GetTypeInfo,
 624     HTMLPluginsCollection_GetIDsOfNames,
 625     HTMLPluginsCollection_Invoke,
 626     HTMLPluginsCollection_get_length,
 627     HTMLPluginsCollection_refresh
 628 };
 629
 630 static inline HTMLPluginsCollection *HTMLPluginsCollection_from_DispatchEx(DispatchEx *iface)
 631 {
 632     return CONTAINING_RECORD(iface, HTMLPluginsCollection, dispex);
 633 }
 634
 635 static void *HTMLPluginsCollection_query_interface(DispatchEx *dispex, REFIID riid)
 636 {
 637     HTMLPluginsCollection *This = HTMLPluginsCollection_from_DispatchEx(dispex);
 638
 639     if(IsEqualGUID(&IID_IHTMLPluginsCollection, riid))
 640         return &This->IHTMLPluginsCollection_iface;
 641
 642     return NULL;
 643 }
 644
 645 static void HTMLPluginsCollection_unlink(DispatchEx *dispex)
 646 {
 647     HTMLPluginsCollection *This = HTMLPluginsCollection_from_DispatchEx(dispex);
 648     if(This->navigator) {
 649         This->navigator->plugins = NULL;
 650         This->navigator = NULL;
 651     }
 652 }
 653
 654 static void HTMLPluginsCollection_destructor(DispatchEx *dispex)
 655 {
 656     HTMLPluginsCollection *This = HTMLPluginsCollection_from_DispatchEx(dispex);
 657     free(This);
 658 }
 659
 660 static const dispex_static_data_vtbl_t HTMLPluginsCollection_dispex_vtbl = {
 661     .query_interface  = HTMLPluginsCollection_query_interface,
 662     .destructor       = HTMLPluginsCollection_destructor,
 663     .unlink           = HTMLPluginsCollection_unlink
 664 };
 665
 666 static const tid_t HTMLPluginsCollection_iface_tids[] = {
 667     IHTMLPluginsCollection_tid,
 668     0
 669 };
 670 static dispex_static_data_t HTMLPluginsCollection_dispex = {
 671     "PluginArray",
 672     &HTMLPluginsCollection_dispex_vtbl,
 673     DispCPlugins_tid,
 674     HTMLPluginsCollection_iface_tids
 675 };
 676
 677 static HRESULT create_plugins_collection(OmNavigator *navigator, HTMLPluginsCollection **ret)
 678 {
 679     HTMLPluginsCollection *col;
 680
 681     col = calloc(1, sizeof(*col));
 682     if(!col)
 683         return E_OUTOFMEMORY;
 684
 685     col->IHTMLPluginsCollection_iface.lpVtbl = &HTMLPluginsCollectionVtbl;
 686     col->navigator = navigator;
 687
 688     init_dispatch_with_owner(&col->dispex, &HTMLPluginsCollection_dispex, &navigator->dispex);
 689
 690     *ret = col;
 691     return S_OK;
 692 }
 693
 694 struct HTMLMimeTypesCollection {
 695     DispatchEx dispex;
 696     IHTMLMimeTypesCollection IHTMLMimeTypesCollection_iface;
 697
 698     OmNavigator *navigator;
 699 };
 700
 701 static inline HTMLMimeTypesCollection *impl_from_IHTMLMimeTypesCollection(IHTMLMimeTypesCollection *iface)
 702 {
 703     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, IHTMLMimeTypesCollection_iface);
 704 }
 705
 706 DISPEX_IDISPATCH_IMPL(HTMLMimeTypesCollection, IHTMLMimeTypesCollection,
 707                       impl_from_IHTMLMimeTypesCollection(iface)->dispex)
 708
 709 static HRESULT WINAPI HTMLMimeTypesCollection_get_length(IHTMLMimeTypesCollection *iface, LONG *p)
 710 {
 711     HTMLMimeTypesCollection *This = impl_from_IHTMLMimeTypesCollection(iface);
 712
 713     TRACE("(%p)->(%p)\n", This, p);
 714
 715     /* This is just a stub for compatibility with other browser in IE */
 716     *p = 0;
 717     return S_OK;
 718 }
 719
 720 static const IHTMLMimeTypesCollectionVtbl HTMLMimeTypesCollectionVtbl = {
 721     HTMLMimeTypesCollection_QueryInterface,
 722     HTMLMimeTypesCollection_AddRef,
 723     HTMLMimeTypesCollection_Release,
 724     HTMLMimeTypesCollection_GetTypeInfoCount,
 725     HTMLMimeTypesCollection_GetTypeInfo,
 726     HTMLMimeTypesCollection_GetIDsOfNames,
 727     HTMLMimeTypesCollection_Invoke,
 728     HTMLMimeTypesCollection_get_length
 729 };
 730
 731 static inline HTMLMimeTypesCollection *HTMLMimeTypesCollection_from_DispatchEx(DispatchEx *iface)
 732 {
 733     return CONTAINING_RECORD(iface, HTMLMimeTypesCollection, dispex);
 734 }
 735
 736 static void *HTMLMimeTypesCollection_query_interface(DispatchEx *dispex, REFIID riid)
 737 {
 738     HTMLMimeTypesCollection *This = HTMLMimeTypesCollection_from_DispatchEx(dispex);
 739
 740     if(IsEqualGUID(&IID_IHTMLMimeTypesCollection, riid))
 741         return &This->IHTMLMimeTypesCollection_iface;
 742
 743     return NULL;
 744 }
 745
 746 static void HTMLMimeTypesCollection_unlink(DispatchEx *dispex)
 747 {
 748     HTMLMimeTypesCollection *This = HTMLMimeTypesCollection_from_DispatchEx(dispex);
 749     if(This->navigator) {
 750         This->navigator->mime_types = NULL;
 751         This->navigator = NULL;
 752     }
 753 }
 754
 755 static void HTMLMimeTypesCollection_destructor(DispatchEx *dispex)
 756 {
 757     HTMLMimeTypesCollection *This = HTMLMimeTypesCollection_from_DispatchEx(dispex);
 758     free(This);
 759 }
 760
 761 static const dispex_static_data_vtbl_t HTMLMimeTypesCollection_dispex_vtbl = {
 762     .query_interface  = HTMLMimeTypesCollection_query_interface,
 763     .destructor       = HTMLMimeTypesCollection_destructor,
 764     .unlink           = HTMLMimeTypesCollection_unlink
 765 };
 766
 767 static const tid_t HTMLMimeTypesCollection_iface_tids[] = {
 768     IHTMLMimeTypesCollection_tid,
 769     0
 770 };
 771 static dispex_static_data_t HTMLMimeTypesCollection_dispex = {
 772     "MimeTypeArray",
 773     &HTMLMimeTypesCollection_dispex_vtbl,
 774     IHTMLMimeTypesCollection_tid,
 775     HTMLMimeTypesCollection_iface_tids
 776 };
 777
 778 static HRESULT create_mime_types_collection(OmNavigator *navigator, HTMLMimeTypesCollection **ret)
 779 {
 780     HTMLMimeTypesCollection *col;
 781
 782     col = calloc(1, sizeof(*col));
 783     if(!col)
 784         return E_OUTOFMEMORY;
 785
 786     col->IHTMLMimeTypesCollection_iface.lpVtbl = &HTMLMimeTypesCollectionVtbl;
 787     col->navigator = navigator;
 788
 789     init_dispatch_with_owner(&col->dispex, &HTMLMimeTypesCollection_dispex, &navigator->dispex);
 790
 791     *ret = col;
 792     return S_OK;
 793 }
 794
 795 static inline OmNavigator *impl_from_IOmNavigator(IOmNavigator *iface)
 796 {
 797     return CONTAINING_RECORD(iface, OmNavigator, IOmNavigator_iface);
 798 }
 799
 800 DISPEX_IDISPATCH_IMPL(OmNavigator, IOmNavigator,impl_from_IOmNavigator(iface)->dispex)
 801
 802 static HRESULT WINAPI OmNavigator_get_appCodeName(IOmNavigator *iface, BSTR *p)
 803 {
 804     OmNavigator *This = impl_from_IOmNavigator(iface);
 805
 806     TRACE("(%p)->(%p)\n", This, p);
 807
 808     *p = SysAllocString(L"Mozilla");
 809     return S_OK;
 810 }
 811
 812 static HRESULT WINAPI OmNavigator_get_appName(IOmNavigator *iface, BSTR *p)
 813 {
 814     OmNavigator *This = impl_from_IOmNavigator(iface);
 815
 816     TRACE("(%p)->(%p)\n", This, p);
 817
 818     *p = SysAllocString(dispex_compat_mode(&This->dispex) == COMPAT_MODE_IE11
 819                         ? L"Netscape" : L"Microsoft Internet Explorer");
 820     if(!*p)
 821         return E_OUTOFMEMORY;
 822
 823     return S_OK;
 824 }
 825
 826 /* undocumented, added in IE8 */
 827 extern HRESULT WINAPI MapBrowserEmulationModeToUserAgent(const void*,WCHAR**);
 828
 829 /* Retrieves allocated user agent via CoTaskMemAlloc */
 830 static HRESULT get_user_agent(OmNavigator *navigator, WCHAR **user_agent)
 831 {
 832     DWORD version = get_compat_mode_version(dispex_compat_mode(&navigator->dispex));
 833
 834     return MapBrowserEmulationModeToUserAgent(&version, user_agent);
 835 }
 836
 837 static HRESULT WINAPI OmNavigator_get_appVersion(IOmNavigator *iface, BSTR *p)
 838 {
 839     OmNavigator *This = impl_from_IOmNavigator(iface);
 840     WCHAR *user_agent;
 841     unsigned len;
 842     HRESULT hres;
 843     const unsigned skip_prefix = strlen("Mozilla/");
 844
 845     TRACE("(%p)->(%p)\n", This, p);
 846
 847     hres = get_user_agent(This, &user_agent);
 848     if(FAILED(hres))
 849         return hres;
 850     len = wcslen(user_agent);
 851
 852     if(len < skip_prefix) {
 853         CoTaskMemFree(user_agent);
 854         *p = NULL;
 855         return S_OK;
 856     }
 857
 858     *p = SysAllocStringLen(user_agent + skip_prefix, len - skip_prefix);
 859     CoTaskMemFree(user_agent);
 860     return *p ? S_OK : E_OUTOFMEMORY;
 861 }
 862
 863 static HRESULT WINAPI OmNavigator_get_userAgent(IOmNavigator *iface, BSTR *p)
 864 {
 865     OmNavigator *This = impl_from_IOmNavigator(iface);
 866     WCHAR *user_agent;
 867     HRESULT hres;
 868
 869     TRACE("(%p)->(%p)\n", This, p);
 870
 871     hres = get_user_agent(This, &user_agent);
 872     if(FAILED(hres))
 873         return hres;
 874
 875     *p = SysAllocString(user_agent);
 876     CoTaskMemFree(user_agent);
 877     return *p ? S_OK : E_OUTOFMEMORY;
 878 }
 879
 880 static HRESULT WINAPI OmNavigator_javaEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
 881 {
 882     OmNavigator *This = impl_from_IOmNavigator(iface);
 883
 884     FIXME("(%p)->(%p) semi-stub\n", This, enabled);
 885
 886     *enabled = VARIANT_TRUE;
 887     return S_OK;
 888 }
 889
 890 static HRESULT WINAPI OmNavigator_taintEnabled(IOmNavigator *iface, VARIANT_BOOL *enabled)
 891 {
 892     OmNavigator *This = impl_from_IOmNavigator(iface);
 893     FIXME("(%p)->(%p)\n", This, enabled);
 894     return E_NOTIMPL;
 895 }
 896
 897 static HRESULT WINAPI OmNavigator_get_mimeTypes(IOmNavigator *iface, IHTMLMimeTypesCollection **p)
 898 {
 899     OmNavigator *This = impl_from_IOmNavigator(iface);
 900
 901     TRACE("(%p)->(%p)\n", This, p);
 902
 903     if(!This->mime_types) {
 904         HRESULT hres;
 905
 906         hres = create_mime_types_collection(This, &This->mime_types);
 907         if(FAILED(hres))
 908             return hres;
 909     }else {
 910         IHTMLMimeTypesCollection_AddRef(&This->mime_types->IHTMLMimeTypesCollection_iface);
 911     }
 912
 913     *p = &This->mime_types->IHTMLMimeTypesCollection_iface;
 914     return S_OK;
 915 }
 916
 917 static HRESULT WINAPI OmNavigator_get_plugins(IOmNavigator *iface, IHTMLPluginsCollection **p)
 918 {
 919     OmNavigator *This = impl_from_IOmNavigator(iface);
 920
 921     TRACE("(%p)->(%p)\n", This, p);
 922
 923     if(!This->plugins) {
 924         HRESULT hres;
 925
 926         hres = create_plugins_collection(This, &This->plugins);
 927         if(FAILED(hres))
 928             return hres;
 929     }else {
 930         IHTMLPluginsCollection_AddRef(&This->plugins->IHTMLPluginsCollection_iface);
 931     }
 932
 933     *p = &This->plugins->IHTMLPluginsCollection_iface;
 934     return S_OK;
 935 }
 936
 937 static HRESULT WINAPI OmNavigator_get_cookieEnabled(IOmNavigator *iface, VARIANT_BOOL *p)
 938 {
 939     OmNavigator *This = impl_from_IOmNavigator(iface);
 940
 941     WARN("(%p)->(%p) semi-stub\n", This, p);
 942
 943     *p = VARIANT_TRUE;
 944     return S_OK;
 945 }
 946
 947 static HRESULT WINAPI OmNavigator_get_opsProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
 948 {
 949     OmNavigator *This = impl_from_IOmNavigator(iface);
 950     FIXME("(%p)->(%p)\n", This, p);
 951     return E_NOTIMPL;
 952 }
 953
 954 static HRESULT WINAPI OmNavigator_toString(IOmNavigator *iface, BSTR *String)
 955 {
 956     OmNavigator *This = impl_from_IOmNavigator(iface);
 957
 958     TRACE("(%p)->(%p)\n", This, String);
 959
 960     return dispex_to_string(&This->dispex, String);
 961 }
 962
 963 static HRESULT WINAPI OmNavigator_get_cpuClass(IOmNavigator *iface, BSTR *p)
 964 {
 965     OmNavigator *This = impl_from_IOmNavigator(iface);
 966
 967     TRACE("(%p)->(%p)\n", This, p);
 968
 969 #ifdef _WIN64
 970     *p = SysAllocString(L"x64");
 971 #else
 972     *p = SysAllocString(L"x86");
 973 #endif
 974     return *p ? S_OK : E_OUTOFMEMORY;
 975 }
 976
 977 static HRESULT get_language_string(LCID lcid, BSTR *p)
 978 {
 979     BSTR ret;
 980     int len;
 981
 982     len = LCIDToLocaleName(lcid, NULL, 0, 0);
 983     if(!len) {
 984         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
 985         return E_FAIL;
 986     }
 987
 988     ret = SysAllocStringLen(NULL, len-1);
 989     if(!ret)
 990         return E_OUTOFMEMORY;
 991
 992     len = LCIDToLocaleName(lcid, ret, len, 0);
 993     if(!len) {
 994         WARN("LCIDToLocaleName failed: %lu\n", GetLastError());
 995         SysFreeString(ret);
 996         return E_FAIL;
 997     }
 998
 999     *p = ret;
1000     return S_OK;
1001 }
1002
1003 static HRESULT WINAPI OmNavigator_get_systemLanguage(IOmNavigator *iface, BSTR *p)
1004 {
1005     OmNavigator *This = impl_from_IOmNavigator(iface);
1006
1007     TRACE("(%p)->(%p)\n", This, p);
1008
1009     return get_language_string(LOCALE_SYSTEM_DEFAULT, p);
1010 }
1011
1012 static HRESULT WINAPI OmNavigator_get_browserLanguage(IOmNavigator *iface, BSTR *p)
1013 {
1014     OmNavigator *This = impl_from_IOmNavigator(iface);
1015
1016     TRACE("(%p)->(%p)\n", This, p);
1017
1018     return get_language_string(GetUserDefaultUILanguage(), p);
1019 }
1020
1021 static HRESULT WINAPI OmNavigator_get_userLanguage(IOmNavigator *iface, BSTR *p)
1022 {
1023     OmNavigator *This = impl_from_IOmNavigator(iface);
1024
1025     TRACE("(%p)->(%p)\n", This, p);
1026
1027     return get_language_string(LOCALE_USER_DEFAULT, p);
1028 }
1029
1030 static HRESULT WINAPI OmNavigator_get_platform(IOmNavigator *iface, BSTR *p)
1031 {
1032     OmNavigator *This = impl_from_IOmNavigator(iface);
1033
1034     TRACE("(%p)->(%p)\n", This, p);
1035
1036 #ifdef _WIN64
1037     *p = SysAllocString(L"Win64");
1038 #else
1039     *p = SysAllocString(L"Win32");
1040 #endif
1041     return S_OK;
1042 }
1043
1044 static HRESULT WINAPI OmNavigator_get_appMinorVersion(IOmNavigator *iface, BSTR *p)
1045 {
1046     OmNavigator *This = impl_from_IOmNavigator(iface);
1047
1048     TRACE("(%p)->(%p)\n", This, p);
1049
1050     /* NOTE: MSIE returns "0" or values like ";SP2;". Returning "0" should be enough. */
1051     *p = SysAllocString(L"0");
1052     return S_OK;
1053 }
1054
1055 static HRESULT WINAPI OmNavigator_get_connectionSpeed(IOmNavigator *iface, LONG *p)
1056 {
1057     OmNavigator *This = impl_from_IOmNavigator(iface);
1058     FIXME("(%p)->(%p)\n", This, p);
1059     return E_NOTIMPL;
1060 }
1061
1062 static HRESULT WINAPI OmNavigator_get_onLine(IOmNavigator *iface, VARIANT_BOOL *p)
1063 {
1064     OmNavigator *This = impl_from_IOmNavigator(iface);
1065
1066     WARN("(%p)->(%p) semi-stub, returning true\n", This, p);
1067
1068     *p = VARIANT_TRUE;
1069     return S_OK;
1070 }
1071
1072 static HRESULT WINAPI OmNavigator_get_userProfile(IOmNavigator *iface, IHTMLOpsProfile **p)
1073 {
1074     OmNavigator *This = impl_from_IOmNavigator(iface);
1075     FIXME("(%p)->(%p)\n", This, p);
1076     return E_NOTIMPL;
1077 }
1078
1079 static const IOmNavigatorVtbl OmNavigatorVtbl = {
1080     OmNavigator_QueryInterface,
1081     OmNavigator_AddRef,
1082     OmNavigator_Release,
1083     OmNavigator_GetTypeInfoCount,
1084     OmNavigator_GetTypeInfo,
1085     OmNavigator_GetIDsOfNames,
1086     OmNavigator_Invoke,
1087     OmNavigator_get_appCodeName,
1088     OmNavigator_get_appName,
1089     OmNavigator_get_appVersion,
1090     OmNavigator_get_userAgent,
1091     OmNavigator_javaEnabled,
1092     OmNavigator_taintEnabled,
1093     OmNavigator_get_mimeTypes,
1094     OmNavigator_get_plugins,
1095     OmNavigator_get_cookieEnabled,
1096     OmNavigator_get_opsProfile,
1097     OmNavigator_toString,
1098     OmNavigator_get_cpuClass,
1099     OmNavigator_get_systemLanguage,
1100     OmNavigator_get_browserLanguage,
1101     OmNavigator_get_userLanguage,
1102     OmNavigator_get_platform,
1103     OmNavigator_get_appMinorVersion,
1104     OmNavigator_get_connectionSpeed,
1105     OmNavigator_get_onLine,
1106     OmNavigator_get_userProfile
1107 };
1108
1109 static inline OmNavigator *OmNavigator_from_DispatchEx(DispatchEx *iface)
1110 {
1111     return CONTAINING_RECORD(iface, OmNavigator, dispex);
1112 }
1113
1114 static void *OmNavigator_query_interface(DispatchEx *dispex, REFIID riid)
1115 {
1116     OmNavigator *This = OmNavigator_from_DispatchEx(dispex);
1117
1118     if(IsEqualGUID(&IID_IOmNavigator, riid))
1119         return &This->IOmNavigator_iface;
1120
1121     return NULL;
1122 }
1123
1124 static void OmNavigator_unlink(DispatchEx *dispex)
1125 {
1126     OmNavigator *This = OmNavigator_from_DispatchEx(dispex);
1127     if(This->plugins) {
1128         This->plugins->navigator = NULL;
1129         This->plugins = NULL;
1130     }
1131     if(This->mime_types) {
1132         This->mime_types->navigator = NULL;
1133         This->mime_types = NULL;
1134     }
1135 }
1136
1137 static void OmNavigator_destructor(DispatchEx *dispex)
1138 {
1139     OmNavigator *This = OmNavigator_from_DispatchEx(dispex);
1140     free(This);
1141 }
1142
1143 static const dispex_static_data_vtbl_t OmNavigator_dispex_vtbl = {
1144     .query_interface  = OmNavigator_query_interface,
1145     .destructor       = OmNavigator_destructor,
1146     .unlink           = OmNavigator_unlink
1147 };
1148
1149 static const tid_t OmNavigator_iface_tids[] = {
1150     IOmNavigator_tid,
1151     0
1152 };
1153 static dispex_static_data_t OmNavigator_dispex = {
1154     "Navigator",
1155     &OmNavigator_dispex_vtbl,
1156     DispHTMLNavigator_tid,
1157     OmNavigator_iface_tids
1158 };
1159
1160 HRESULT create_navigator(HTMLInnerWindow *script_global, IOmNavigator **navigator)
1161 {
1162     OmNavigator *ret;
1163
1164     ret = calloc(1, sizeof(*ret));
1165     if(!ret)
1166         return E_OUTOFMEMORY;
1167
1168     ret->IOmNavigator_iface.lpVtbl = &OmNavigatorVtbl;
1169
1170     init_dispatch(&ret->dispex, &OmNavigator_dispex, script_global,
1171                   dispex_compat_mode(&script_global->event_target.dispex));
1172
1173     *navigator = &ret->IOmNavigator_iface;
1174     return S_OK;
1175 }
1176
1177 typedef struct {
1178     DispatchEx dispex;
1179     IHTMLPerformanceTiming IHTMLPerformanceTiming_iface;
1180
1181     HTMLInnerWindow *window;
1182 } HTMLPerformanceTiming;
1183
1184 static inline HTMLPerformanceTiming *impl_from_IHTMLPerformanceTiming(IHTMLPerformanceTiming *iface)
1185 {
1186     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, IHTMLPerformanceTiming_iface);
1187 }
1188
1189 DISPEX_IDISPATCH_IMPL(HTMLPerformanceTiming, IHTMLPerformanceTiming,
1190                       impl_from_IHTMLPerformanceTiming(iface)->dispex)
1191
1192 static ULONGLONG get_fetch_time(HTMLPerformanceTiming *This)
1193 {
1194     HTMLInnerWindow *window = This->window;
1195
1196     /* If there's no prior doc unloaded and no redirects, fetch time == navigationStart time */
1197     if(!window->unload_event_end_time && !window->redirect_time)
1198         return window->navigation_start_time;
1199
1200     if(window->dns_lookup_time)
1201         return window->dns_lookup_time;
1202     if(window->connect_time)
1203         return window->connect_time;
1204     if(window->request_time)
1205         return window->request_time;
1206     if(window->unload_event_end_time)
1207         return window->unload_event_end_time;
1208
1209     return window->redirect_time;
1210 }
1211
1212 static HRESULT WINAPI HTMLPerformanceTiming_get_navigationStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1213 {
1214     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1215
1216     TRACE("(%p)->(%p)\n", This, p);
1217
1218     *p = This->window->navigation_start_time;
1219     return S_OK;
1220 }
1221
1222 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1223 {
1224     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1225
1226     TRACE("(%p)->(%p)\n", This, p);
1227
1228     *p = This->window->unload_event_start_time;
1229     return S_OK;
1230 }
1231
1232 static HRESULT WINAPI HTMLPerformanceTiming_get_unloadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1233 {
1234     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1235
1236     TRACE("(%p)->(%p)\n", This, p);
1237
1238     *p = This->window->unload_event_end_time;
1239     return S_OK;
1240 }
1241
1242 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1243 {
1244     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1245
1246     TRACE("(%p)->(%p)\n", This, p);
1247
1248     *p = This->window->redirect_time;
1249     return S_OK;
1250 }
1251
1252 static HRESULT WINAPI HTMLPerformanceTiming_get_redirectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1253 {
1254     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1255
1256     TRACE("(%p)->(%p)\n", This, p);
1257
1258     *p = This->window->redirect_time ? get_fetch_time(This) : 0;
1259     return S_OK;
1260 }
1261
1262 static HRESULT WINAPI HTMLPerformanceTiming_get_fetchStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1263 {
1264     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1265
1266     TRACE("(%p)->(%p)\n", This, p);
1267
1268     *p = get_fetch_time(This);
1269     return S_OK;
1270 }
1271
1272 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1273 {
1274     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1275
1276     TRACE("(%p)->(%p)\n", This, p);
1277
1278     *p = This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1279     return S_OK;
1280 }
1281
1282 static HRESULT WINAPI HTMLPerformanceTiming_get_domainLookupEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1283 {
1284     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1285
1286     TRACE("(%p)->(%p)\n", This, p);
1287
1288     *p = This->window->connect_time    ? This->window->connect_time    :
1289          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1290     return S_OK;
1291 }
1292
1293 static HRESULT WINAPI HTMLPerformanceTiming_get_connectStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1294 {
1295     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1296
1297     TRACE("(%p)->(%p)\n", This, p);
1298
1299     *p = This->window->connect_time    ? This->window->connect_time    :
1300          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1301     return S_OK;
1302 }
1303
1304 static HRESULT WINAPI HTMLPerformanceTiming_get_connectEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1305 {
1306     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1307
1308     TRACE("(%p)->(%p)\n", This, p);
1309
1310     *p = This->window->request_time    ? This->window->request_time    :
1311          This->window->connect_time    ? This->window->connect_time    :
1312          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1313     return S_OK;
1314 }
1315
1316 static HRESULT WINAPI HTMLPerformanceTiming_get_requestStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1317 {
1318     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1319
1320     TRACE("(%p)->(%p)\n", This, p);
1321
1322     *p = This->window->request_time    ? This->window->request_time    :
1323          This->window->connect_time    ? This->window->connect_time    :
1324          This->window->dns_lookup_time ? This->window->dns_lookup_time : get_fetch_time(This);
1325     return S_OK;
1326 }
1327
1328 static HRESULT WINAPI HTMLPerformanceTiming_get_responseStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1329 {
1330     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1331
1332     TRACE("(%p)->(%p)\n", This, p);
1333
1334     *p = This->window->response_start_time;
1335     return S_OK;
1336 }
1337
1338 static HRESULT WINAPI HTMLPerformanceTiming_get_responseEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1339 {
1340     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1341
1342     TRACE("(%p)->(%p)\n", This, p);
1343
1344     *p = This->window->response_end_time;
1345     return S_OK;
1346 }
1347
1348 static HRESULT WINAPI HTMLPerformanceTiming_get_domLoading(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1349 {
1350     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1351
1352     TRACE("(%p)->(%p)\n", This, p);
1353
1354     /* Make sure this is after responseEnd, when the Gecko parser starts */
1355     *p = This->window->response_end_time;
1356     return S_OK;
1357 }
1358
1359 static HRESULT WINAPI HTMLPerformanceTiming_get_domInteractive(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1360 {
1361     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1362
1363     TRACE("(%p)->(%p)\n", This, p);
1364
1365     *p = This->window->dom_interactive_time;
1366     return S_OK;
1367 }
1368
1369 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1370 {
1371     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1372
1373     TRACE("(%p)->(%p)\n", This, p);
1374
1375     *p = This->window->dom_content_loaded_event_start_time;
1376     return S_OK;
1377 }
1378
1379 static HRESULT WINAPI HTMLPerformanceTiming_get_domContentLoadedEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1380 {
1381     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1382
1383     TRACE("(%p)->(%p)\n", This, p);
1384
1385     *p = This->window->dom_content_loaded_event_end_time;
1386     return S_OK;
1387 }
1388
1389 static HRESULT WINAPI HTMLPerformanceTiming_get_domComplete(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1390 {
1391     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1392
1393     TRACE("(%p)->(%p)\n", This, p);
1394
1395     *p = This->window->dom_complete_time;
1396     return S_OK;
1397 }
1398
1399 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventStart(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1400 {
1401     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1402
1403     TRACE("(%p)->(%p)\n", This, p);
1404
1405     *p = This->window->load_event_start_time;
1406     return S_OK;
1407 }
1408
1409 static HRESULT WINAPI HTMLPerformanceTiming_get_loadEventEnd(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1410 {
1411     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1412
1413     TRACE("(%p)->(%p)\n", This, p);
1414
1415     *p = This->window->load_event_end_time;
1416     return S_OK;
1417 }
1418
1419 static HRESULT WINAPI HTMLPerformanceTiming_get_msFirstPaint(IHTMLPerformanceTiming *iface, ULONGLONG *p)
1420 {
1421     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1422
1423     TRACE("(%p)->(%p)\n", This, p);
1424
1425     *p = This->window->first_paint_time;
1426     return S_OK;
1427 }
1428
1429 static HRESULT WINAPI HTMLPerformanceTiming_toString(IHTMLPerformanceTiming *iface, BSTR *string)
1430 {
1431     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1432
1433     TRACE("(%p)->(%p)\n", This, string);
1434
1435     return dispex_to_string(&This->dispex, string);
1436 }
1437
1438 static HRESULT WINAPI HTMLPerformanceTiming_toJSON(IHTMLPerformanceTiming *iface, VARIANT *p)
1439 {
1440     HTMLPerformanceTiming *This = impl_from_IHTMLPerformanceTiming(iface);
1441     FIXME("(%p)->(%p)\n", This, p);
1442     return E_NOTIMPL;
1443 }
1444
1445 static const IHTMLPerformanceTimingVtbl HTMLPerformanceTimingVtbl = {
1446     HTMLPerformanceTiming_QueryInterface,
1447     HTMLPerformanceTiming_AddRef,
1448     HTMLPerformanceTiming_Release,
1449     HTMLPerformanceTiming_GetTypeInfoCount,
1450     HTMLPerformanceTiming_GetTypeInfo,
1451     HTMLPerformanceTiming_GetIDsOfNames,
1452     HTMLPerformanceTiming_Invoke,
1453     HTMLPerformanceTiming_get_navigationStart,
1454     HTMLPerformanceTiming_get_unloadEventStart,
1455     HTMLPerformanceTiming_get_unloadEventEnd,
1456     HTMLPerformanceTiming_get_redirectStart,
1457     HTMLPerformanceTiming_get_redirectEnd,
1458     HTMLPerformanceTiming_get_fetchStart,
1459     HTMLPerformanceTiming_get_domainLookupStart,
1460     HTMLPerformanceTiming_get_domainLookupEnd,
1461     HTMLPerformanceTiming_get_connectStart,
1462     HTMLPerformanceTiming_get_connectEnd,
1463     HTMLPerformanceTiming_get_requestStart,
1464     HTMLPerformanceTiming_get_responseStart,
1465     HTMLPerformanceTiming_get_responseEnd,
1466     HTMLPerformanceTiming_get_domLoading,
1467     HTMLPerformanceTiming_get_domInteractive,
1468     HTMLPerformanceTiming_get_domContentLoadedEventStart,
1469     HTMLPerformanceTiming_get_domContentLoadedEventEnd,
1470     HTMLPerformanceTiming_get_domComplete,
1471     HTMLPerformanceTiming_get_loadEventStart,
1472     HTMLPerformanceTiming_get_loadEventEnd,
1473     HTMLPerformanceTiming_get_msFirstPaint,
1474     HTMLPerformanceTiming_toString,
1475     HTMLPerformanceTiming_toJSON
1476 };
1477
1478 static inline HTMLPerformanceTiming *HTMLPerformanceTiming_from_DispatchEx(DispatchEx *iface)
1479 {
1480     return CONTAINING_RECORD(iface, HTMLPerformanceTiming, dispex);
1481 }
1482
1483 static void *HTMLPerformanceTiming_query_interface(DispatchEx *dispex, REFIID riid)
1484 {
1485     HTMLPerformanceTiming *This = HTMLPerformanceTiming_from_DispatchEx(dispex);
1486
1487     if(IsEqualGUID(&IID_IHTMLPerformanceTiming, riid))
1488         return &This->IHTMLPerformanceTiming_iface;
1489
1490     return NULL;
1491 }
1492
1493 static void HTMLPerformanceTiming_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
1494 {
1495     HTMLPerformanceTiming *This = HTMLPerformanceTiming_from_DispatchEx(dispex);
1496     if(This->window)
1497         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
1498 }
1499
1500 static void HTMLPerformanceTiming_unlink(DispatchEx *dispex)
1501 {
1502     HTMLPerformanceTiming *This = HTMLPerformanceTiming_from_DispatchEx(dispex);
1503     if(This->window) {
1504         HTMLInnerWindow *window = This->window;
1505         This->window = NULL;
1506         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
1507     }
1508 }
1509
1510 static void HTMLPerformanceTiming_destructor(DispatchEx *dispex)
1511 {
1512     HTMLPerformanceTiming *This = HTMLPerformanceTiming_from_DispatchEx(dispex);
1513     free(This);
1514 }
1515
1516 static const dispex_static_data_vtbl_t HTMLPerformanceTiming_dispex_vtbl = {
1517     .query_interface  = HTMLPerformanceTiming_query_interface,
1518     .destructor       = HTMLPerformanceTiming_destructor,
1519     .traverse         = HTMLPerformanceTiming_traverse,
1520     .unlink           = HTMLPerformanceTiming_unlink
1521 };
1522
1523 static const tid_t HTMLPerformanceTiming_iface_tids[] = {
1524     IHTMLPerformanceTiming_tid,
1525     0
1526 };
1527 static dispex_static_data_t HTMLPerformanceTiming_dispex = {
1528     "PerformanceTiming",
1529     &HTMLPerformanceTiming_dispex_vtbl,
1530     IHTMLPerformanceTiming_tid,
1531     HTMLPerformanceTiming_iface_tids
1532 };
1533
1534 typedef struct {
1535     DispatchEx dispex;
1536     IHTMLPerformanceNavigation IHTMLPerformanceNavigation_iface;
1537
1538     HTMLInnerWindow *window;
1539 } HTMLPerformanceNavigation;
1540
1541 static inline HTMLPerformanceNavigation *impl_from_IHTMLPerformanceNavigation(IHTMLPerformanceNavigation *iface)
1542 {
1543     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, IHTMLPerformanceNavigation_iface);
1544 }
1545
1546 DISPEX_IDISPATCH_IMPL(HTMLPerformanceNavigation, IHTMLPerformanceNavigation,
1547                       impl_from_IHTMLPerformanceNavigation(iface)->dispex)
1548
1549 static HRESULT WINAPI HTMLPerformanceNavigation_get_type(IHTMLPerformanceNavigation *iface, ULONG *p)
1550 {
1551     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1552
1553     TRACE("(%p)->(%p)\n", This, p);
1554
1555     *p = This->window->navigation_type;
1556     return S_OK;
1557 }
1558
1559 static HRESULT WINAPI HTMLPerformanceNavigation_get_redirectCount(IHTMLPerformanceNavigation *iface, ULONG *p)
1560 {
1561     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1562
1563     TRACE("(%p)->(%p)\n", This, p);
1564
1565     *p = This->window->redirect_count;
1566     return S_OK;
1567 }
1568
1569 static HRESULT WINAPI HTMLPerformanceNavigation_toString(IHTMLPerformanceNavigation *iface, BSTR *string)
1570 {
1571     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1572
1573     TRACE("(%p)->(%p)\n", This, string);
1574
1575     return dispex_to_string(&This->dispex, string);
1576 }
1577
1578 static HRESULT WINAPI HTMLPerformanceNavigation_toJSON(IHTMLPerformanceNavigation *iface, VARIANT *p)
1579 {
1580     HTMLPerformanceNavigation *This = impl_from_IHTMLPerformanceNavigation(iface);
1581     FIXME("(%p)->(%p)\n", This, p);
1582     return E_NOTIMPL;
1583 }
1584
1585 static const IHTMLPerformanceNavigationVtbl HTMLPerformanceNavigationVtbl = {
1586     HTMLPerformanceNavigation_QueryInterface,
1587     HTMLPerformanceNavigation_AddRef,
1588     HTMLPerformanceNavigation_Release,
1589     HTMLPerformanceNavigation_GetTypeInfoCount,
1590     HTMLPerformanceNavigation_GetTypeInfo,
1591     HTMLPerformanceNavigation_GetIDsOfNames,
1592     HTMLPerformanceNavigation_Invoke,
1593     HTMLPerformanceNavigation_get_type,
1594     HTMLPerformanceNavigation_get_redirectCount,
1595     HTMLPerformanceNavigation_toString,
1596     HTMLPerformanceNavigation_toJSON
1597 };
1598
1599 static inline HTMLPerformanceNavigation *HTMLPerformanceNavigation_from_DispatchEx(DispatchEx *iface)
1600 {
1601     return CONTAINING_RECORD(iface, HTMLPerformanceNavigation, dispex);
1602 }
1603
1604 static void *HTMLPerformanceNavigation_query_interface(DispatchEx *dispex, REFIID riid)
1605 {
1606     HTMLPerformanceNavigation *This = HTMLPerformanceNavigation_from_DispatchEx(dispex);
1607
1608     if(IsEqualGUID(&IID_IHTMLPerformanceNavigation, riid))
1609         return &This->IHTMLPerformanceNavigation_iface;
1610
1611     return NULL;
1612 }
1613
1614 static void HTMLPerformanceNavigation_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
1615 {
1616     HTMLPerformanceNavigation *This = HTMLPerformanceNavigation_from_DispatchEx(dispex);
1617     if(This->window)
1618         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
1619 }
1620
1621 static void HTMLPerformanceNavigation_unlink(DispatchEx *dispex)
1622 {
1623     HTMLPerformanceNavigation *This = HTMLPerformanceNavigation_from_DispatchEx(dispex);
1624     if(This->window) {
1625         HTMLInnerWindow *window = This->window;
1626         This->window = NULL;
1627         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
1628     }
1629 }
1630
1631 static void HTMLPerformanceNavigation_destructor(DispatchEx *dispex)
1632 {
1633     HTMLPerformanceNavigation *This = HTMLPerformanceNavigation_from_DispatchEx(dispex);
1634     free(This);
1635 }
1636
1637 static const dispex_static_data_vtbl_t HTMLPerformanceNavigation_dispex_vtbl = {
1638     .query_interface  = HTMLPerformanceNavigation_query_interface,
1639     .destructor       = HTMLPerformanceNavigation_destructor,
1640     .traverse         = HTMLPerformanceNavigation_traverse,
1641     .unlink           = HTMLPerformanceNavigation_unlink
1642 };
1643
1644 static const tid_t HTMLPerformanceNavigation_iface_tids[] = {
1645     IHTMLPerformanceNavigation_tid,
1646     0
1647 };
1648 static dispex_static_data_t HTMLPerformanceNavigation_dispex = {
1649     "PerformanceNavigation",
1650     &HTMLPerformanceNavigation_dispex_vtbl,
1651     IHTMLPerformanceNavigation_tid,
1652     HTMLPerformanceNavigation_iface_tids
1653 };
1654
1655 typedef struct {
1656     DispatchEx dispex;
1657     IHTMLPerformance IHTMLPerformance_iface;
1658
1659     HTMLInnerWindow *window;
1660     IHTMLPerformanceNavigation *navigation;
1661     IHTMLPerformanceTiming *timing;
1662 } HTMLPerformance;
1663
1664 static inline HTMLPerformance *impl_from_IHTMLPerformance(IHTMLPerformance *iface)
1665 {
1666     return CONTAINING_RECORD(iface, HTMLPerformance, IHTMLPerformance_iface);
1667 }
1668
1669 DISPEX_IDISPATCH_IMPL(HTMLPerformance, IHTMLPerformance, impl_from_IHTMLPerformance(iface)->dispex)
1670
1671 static HRESULT WINAPI HTMLPerformance_get_navigation(IHTMLPerformance *iface,
1672                                                      IHTMLPerformanceNavigation **p)
1673 {
1674     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1675
1676     TRACE("(%p)->(%p)\n", This, p);
1677
1678     if(!This->navigation) {
1679         HTMLPerformanceNavigation *navigation;
1680
1681         navigation = calloc(1, sizeof(*navigation));
1682         if(!navigation)
1683             return E_OUTOFMEMORY;
1684
1685         navigation->IHTMLPerformanceNavigation_iface.lpVtbl = &HTMLPerformanceNavigationVtbl;
1686         navigation->window = This->window;
1687         IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
1688
1689         init_dispatch(&navigation->dispex, &HTMLPerformanceNavigation_dispex, This->window,
1690                       dispex_compat_mode(&This->dispex));
1691
1692         This->navigation = &navigation->IHTMLPerformanceNavigation_iface;
1693     }
1694
1695     IHTMLPerformanceNavigation_AddRef(*p = This->navigation);
1696     return S_OK;
1697 }
1698
1699 static HRESULT WINAPI HTMLPerformance_get_timing(IHTMLPerformance *iface, IHTMLPerformanceTiming **p)
1700 {
1701     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1702
1703     TRACE("(%p)->(%p)\n", This, p);
1704
1705     if(!This->timing) {
1706         HTMLPerformanceTiming *timing;
1707
1708         timing = calloc(1, sizeof(*timing));
1709         if(!timing)
1710             return E_OUTOFMEMORY;
1711
1712         timing->IHTMLPerformanceTiming_iface.lpVtbl = &HTMLPerformanceTimingVtbl;
1713         timing->window = This->window;
1714         IHTMLWindow2_AddRef(&This->window->base.IHTMLWindow2_iface);
1715
1716         init_dispatch(&timing->dispex, &HTMLPerformanceTiming_dispex, This->window,
1717                       dispex_compat_mode(&This->dispex));
1718
1719         This->timing = &timing->IHTMLPerformanceTiming_iface;
1720     }
1721
1722     IHTMLPerformanceTiming_AddRef(*p = This->timing);
1723     return S_OK;
1724 }
1725
1726 static HRESULT WINAPI HTMLPerformance_toString(IHTMLPerformance *iface, BSTR *string)
1727 {
1728     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1729
1730     TRACE("(%p)->(%p)\n", This, string);
1731
1732     return dispex_to_string(&This->dispex, string);
1733 }
1734
1735 static HRESULT WINAPI HTMLPerformance_toJSON(IHTMLPerformance *iface, VARIANT *var)
1736 {
1737     HTMLPerformance *This = impl_from_IHTMLPerformance(iface);
1738     FIXME("(%p)->(%p)\n", This, var);
1739     return E_NOTIMPL;
1740 }
1741
1742 static const IHTMLPerformanceVtbl HTMLPerformanceVtbl = {
1743     HTMLPerformance_QueryInterface,
1744     HTMLPerformance_AddRef,
1745     HTMLPerformance_Release,
1746     HTMLPerformance_GetTypeInfoCount,
1747     HTMLPerformance_GetTypeInfo,
1748     HTMLPerformance_GetIDsOfNames,
1749     HTMLPerformance_Invoke,
1750     HTMLPerformance_get_navigation,
1751     HTMLPerformance_get_timing,
1752     HTMLPerformance_toString,
1753     HTMLPerformance_toJSON
1754 };
1755
1756 static inline HTMLPerformance *HTMLPerformance_from_DispatchEx(DispatchEx *iface)
1757 {
1758     return CONTAINING_RECORD(iface, HTMLPerformance, dispex);
1759 }
1760
1761 static void *HTMLPerformance_query_interface(DispatchEx *dispex, REFIID riid)
1762 {
1763     HTMLPerformance *This = HTMLPerformance_from_DispatchEx(dispex);
1764
1765     if(IsEqualGUID(&IID_IHTMLPerformance, riid))
1766         return &This->IHTMLPerformance_iface;
1767
1768     return NULL;
1769 }
1770
1771 static void HTMLPerformance_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
1772 {
1773     HTMLPerformance *This = HTMLPerformance_from_DispatchEx(dispex);
1774     if(This->window)
1775         note_cc_edge((nsISupports*)&This->window->base.IHTMLWindow2_iface, "window", cb);
1776     if(This->navigation)
1777         note_cc_edge((nsISupports*)This->navigation, "navigation", cb);
1778     if(This->timing)
1779         note_cc_edge((nsISupports*)This->timing, "timing", cb);
1780 }
1781
1782 static void HTMLPerformance_unlink(DispatchEx *dispex)
1783 {
1784     HTMLPerformance *This = HTMLPerformance_from_DispatchEx(dispex);
1785     if(This->window) {
1786         HTMLInnerWindow *window = This->window;
1787         This->window = NULL;
1788         IHTMLWindow2_Release(&window->base.IHTMLWindow2_iface);
1789     }
1790     unlink_ref(&This->navigation);
1791     unlink_ref(&This->timing);
1792 }
1793
1794 static void HTMLPerformance_destructor(DispatchEx *dispex)
1795 {
1796     HTMLPerformance *This = HTMLPerformance_from_DispatchEx(dispex);
1797     free(This);
1798 }
1799
1800 static const dispex_static_data_vtbl_t HTMLPerformance_dispex_vtbl = {
1801     .query_interface  = HTMLPerformance_query_interface,
1802     .destructor       = HTMLPerformance_destructor,
1803     .traverse         = HTMLPerformance_traverse,
1804     .unlink           = HTMLPerformance_unlink
1805 };
1806
1807 static const tid_t HTMLPerformance_iface_tids[] = {
1808     IHTMLPerformance_tid,
1809     0
1810 };
1811 static dispex_static_data_t HTMLPerformance_dispex = {
1812     "Performance",
1813     &HTMLPerformance_dispex_vtbl,
1814     IHTMLPerformance_tid,
1815     HTMLPerformance_iface_tids
1816 };
1817
1818 HRESULT create_performance(HTMLInnerWindow *window, IHTMLPerformance **ret)
1819 {
1820     compat_mode_t compat_mode = dispex_compat_mode(&window->event_target.dispex);
1821     HTMLPerformance *performance;
1822
1823     performance = calloc(1, sizeof(*performance));
1824     if(!performance)
1825         return E_OUTOFMEMORY;
1826
1827     performance->IHTMLPerformance_iface.lpVtbl = &HTMLPerformanceVtbl;
1828     performance->window = window;
1829     IHTMLWindow2_AddRef(&window->base.IHTMLWindow2_iface);
1830
1831     init_dispatch(&performance->dispex, &HTMLPerformance_dispex, window, compat_mode);
1832
1833     *ret = &performance->IHTMLPerformance_iface;
1834     return S_OK;
1835 }
1836
1837 typedef struct {
1838     DispatchEx dispex;
1839     IHTMLNamespaceCollection IHTMLNamespaceCollection_iface;
1840 } HTMLNamespaceCollection;
1841
1842 static inline HTMLNamespaceCollection *impl_from_IHTMLNamespaceCollection(IHTMLNamespaceCollection *iface)
1843 {
1844     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, IHTMLNamespaceCollection_iface);
1845 }
1846
1847 DISPEX_IDISPATCH_IMPL(HTMLNamespaceCollection, IHTMLNamespaceCollection,
1848                       impl_from_IHTMLNamespaceCollection(iface)->dispex)
1849
1850 static HRESULT WINAPI HTMLNamespaceCollection_get_length(IHTMLNamespaceCollection *iface, LONG *p)
1851 {
1852     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
1853     FIXME("(%p)->(%p) returning 0\n", This, p);
1854     *p = 0;
1855     return S_OK;
1856 }
1857
1858 static HRESULT WINAPI HTMLNamespaceCollection_item(IHTMLNamespaceCollection *iface, VARIANT index, IDispatch **p)
1859 {
1860     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
1861     FIXME("(%p)->(%s %p)\n", This, debugstr_variant(&index), p);
1862     return E_NOTIMPL;
1863 }
1864
1865 static HRESULT WINAPI HTMLNamespaceCollection_add(IHTMLNamespaceCollection *iface, BSTR namespace, BSTR urn,
1866                                                   VARIANT implementation_url, IDispatch **p)
1867 {
1868     HTMLNamespaceCollection *This = impl_from_IHTMLNamespaceCollection(iface);
1869     FIXME("(%p)->(%s %s %s %p)\n", This, debugstr_w(namespace), debugstr_w(urn), debugstr_variant(&implementation_url), p);
1870     return E_NOTIMPL;
1871 }
1872
1873 static const IHTMLNamespaceCollectionVtbl HTMLNamespaceCollectionVtbl = {
1874     HTMLNamespaceCollection_QueryInterface,
1875     HTMLNamespaceCollection_AddRef,
1876     HTMLNamespaceCollection_Release,
1877     HTMLNamespaceCollection_GetTypeInfoCount,
1878     HTMLNamespaceCollection_GetTypeInfo,
1879     HTMLNamespaceCollection_GetIDsOfNames,
1880     HTMLNamespaceCollection_Invoke,
1881     HTMLNamespaceCollection_get_length,
1882     HTMLNamespaceCollection_item,
1883     HTMLNamespaceCollection_add
1884 };
1885
1886 static inline HTMLNamespaceCollection *HTMLNamespaceCollection_from_DispatchEx(DispatchEx *iface)
1887 {
1888     return CONTAINING_RECORD(iface, HTMLNamespaceCollection, dispex);
1889 }
1890
1891 static void *HTMLNamespaceCollection_query_interface(DispatchEx *dispex, REFIID riid)
1892 {
1893     HTMLNamespaceCollection *This = HTMLNamespaceCollection_from_DispatchEx(dispex);
1894
1895     if(IsEqualGUID(&IID_IHTMLNamespaceCollection, riid))
1896         return &This->IHTMLNamespaceCollection_iface;
1897
1898     return NULL;
1899 }
1900
1901 static void HTMLNamespaceCollection_destructor(DispatchEx *dispex)
1902 {
1903     HTMLNamespaceCollection *This = HTMLNamespaceCollection_from_DispatchEx(dispex);
1904     free(This);
1905 }
1906
1907 static const dispex_static_data_vtbl_t HTMLNamespaceCollection_dispex_vtbl = {
1908     .query_interface  = HTMLNamespaceCollection_query_interface,
1909     .destructor       = HTMLNamespaceCollection_destructor,
1910 };
1911
1912 static const tid_t HTMLNamespaceCollection_iface_tids[] = {
1913     IHTMLNamespaceCollection_tid,
1914     0
1915 };
1916 static dispex_static_data_t HTMLNamespaceCollection_dispex = {
1917     "MSNamespaceInfoCollection",
1918     &HTMLNamespaceCollection_dispex_vtbl,
1919     DispHTMLNamespaceCollection_tid,
1920     HTMLNamespaceCollection_iface_tids
1921 };
1922
1923 HRESULT create_namespace_collection(HTMLDocumentNode *doc, IHTMLNamespaceCollection **ret)
1924 {
1925     HTMLNamespaceCollection *namespaces;
1926
1927     if (!(namespaces = calloc(1, sizeof(*namespaces))))
1928         return E_OUTOFMEMORY;
1929
1930     namespaces->IHTMLNamespaceCollection_iface.lpVtbl = &HTMLNamespaceCollectionVtbl;
1931     init_dispatch(&namespaces->dispex, &HTMLNamespaceCollection_dispex, doc->script_global,
1932                   dispex_compat_mode(&doc->node.event_target.dispex));
1933     *ret = &namespaces->IHTMLNamespaceCollection_iface;
1934     return S_OK;
1935 }
1936
1937 struct console {
1938     DispatchEx dispex;
1939     IWineMSHTMLConsole IWineMSHTMLConsole_iface;
1940 };
1941
1942 static inline struct console *impl_from_IWineMSHTMLConsole(IWineMSHTMLConsole *iface)
1943 {
1944     return CONTAINING_RECORD(iface, struct console, IWineMSHTMLConsole_iface);
1945 }
1946
1947 DISPEX_IDISPATCH_IMPL(console, IWineMSHTMLConsole, impl_from_IWineMSHTMLConsole(iface)->dispex)
1948
1949 static HRESULT WINAPI console_assert(IWineMSHTMLConsole *iface, VARIANT_BOOL *assertion, VARIANT *vararg_start)
1950 {
1951     FIXME("iface %p, assertion %p, vararg_start %p stub.\n", iface, assertion, vararg_start);
1952
1953     return S_OK;
1954 }
1955
1956 static HRESULT WINAPI console_clear(IWineMSHTMLConsole *iface)
1957 {
1958     FIXME("iface %p stub.\n", iface);
1959
1960     return S_OK;
1961 }
1962
1963 static HRESULT WINAPI console_count(IWineMSHTMLConsole *iface, VARIANT *label)
1964 {
1965     FIXME("iface %p, label %p stub.\n", iface, label);
1966
1967     return S_OK;
1968 }
1969
1970 static HRESULT WINAPI console_debug(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
1971 {
1972     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
1973
1974     return S_OK;
1975 }
1976
1977 static HRESULT WINAPI console_dir(IWineMSHTMLConsole *iface, VARIANT *object)
1978 {
1979     FIXME("iface %p, object %p stub.\n", iface, object);
1980
1981     return S_OK;
1982 }
1983
1984 static HRESULT WINAPI console_dirxml(IWineMSHTMLConsole *iface, VARIANT *object)
1985 {
1986     FIXME("iface %p, object %p stub.\n", iface, object);
1987
1988     return S_OK;
1989 }
1990
1991 static HRESULT WINAPI console_error(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
1992 {
1993     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
1994
1995     return S_OK;
1996 }
1997
1998 static HRESULT WINAPI console_group(IWineMSHTMLConsole *iface, VARIANT *label)
1999 {
2000     FIXME("iface %p, label %p stub.\n", iface, label);
2001
2002     return S_OK;
2003 }
2004
2005 static HRESULT WINAPI console_group_collapsed(IWineMSHTMLConsole *iface, VARIANT *label)
2006 {
2007     FIXME("iface %p, label %p stub.\n", iface, label);
2008
2009     return S_OK;
2010 }
2011
2012 static HRESULT WINAPI console_group_end(IWineMSHTMLConsole *iface)
2013 {
2014     FIXME("iface %p, stub.\n", iface);
2015
2016     return S_OK;
2017 }
2018
2019 static HRESULT WINAPI console_info(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2020 {
2021     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2022
2023     return S_OK;
2024 }
2025
2026 static HRESULT WINAPI console_log(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2027 {
2028     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2029
2030     return S_OK;
2031 }
2032
2033 static HRESULT WINAPI console_time(IWineMSHTMLConsole *iface, VARIANT *label)
2034 {
2035     FIXME("iface %p, label %p stub.\n", iface, label);
2036
2037     return S_OK;
2038 }
2039
2040 static HRESULT WINAPI console_time_end(IWineMSHTMLConsole *iface, VARIANT *label)
2041 {
2042     FIXME("iface %p, label %p stub.\n", iface, label);
2043
2044     return S_OK;
2045 }
2046
2047 static HRESULT WINAPI console_trace(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2048 {
2049     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2050
2051     return S_OK;
2052 }
2053
2054 static HRESULT WINAPI console_warn(IWineMSHTMLConsole *iface, VARIANT *vararg_start)
2055 {
2056     FIXME("iface %p, vararg_start %p stub.\n", iface, vararg_start);
2057
2058     return S_OK;
2059 }
2060
2061 static const IWineMSHTMLConsoleVtbl WineMSHTMLConsoleVtbl = {
2062     console_QueryInterface,
2063     console_AddRef,
2064     console_Release,
2065     console_GetTypeInfoCount,
2066     console_GetTypeInfo,
2067     console_GetIDsOfNames,
2068     console_Invoke,
2069     console_assert,
2070     console_clear,
2071     console_count,
2072     console_debug,
2073     console_dir,
2074     console_dirxml,
2075     console_error,
2076     console_group,
2077     console_group_collapsed,
2078     console_group_end,
2079     console_info,
2080     console_log,
2081     console_time,
2082     console_time_end,
2083     console_trace,
2084     console_warn,
2085 };
2086
2087 static inline struct console *console_from_DispatchEx(DispatchEx *iface)
2088 {
2089     return CONTAINING_RECORD(iface, struct console, dispex);
2090 }
2091
2092 static void *console_query_interface(DispatchEx *dispex, REFIID riid)
2093 {
2094     struct console *console = console_from_DispatchEx(dispex);
2095
2096     if(IsEqualGUID(&IID_IWineMSHTMLConsole, riid))
2097         return &console->IWineMSHTMLConsole_iface;
2098
2099     return NULL;
2100 }
2101
2102 static void console_destructor(DispatchEx *dispex)
2103 {
2104     struct console *console = console_from_DispatchEx(dispex);
2105     free(console);
2106 }
2107
2108 static const dispex_static_data_vtbl_t console_dispex_vtbl = {
2109     .query_interface  = console_query_interface,
2110     .destructor       = console_destructor,
2111 };
2112
2113 static const tid_t console_iface_tids[] = {
2114     IWineMSHTMLConsole_tid,
2115     0
2116 };
2117 static dispex_static_data_t console_dispex = {
2118     "Console",
2119     &console_dispex_vtbl,
2120     IWineMSHTMLConsole_tid,
2121     console_iface_tids
2122 };
2123
2124 void create_console(HTMLInnerWindow *window, IWineMSHTMLConsole **ret)
2125 {
2126     struct console *obj;
2127
2128     obj = calloc(1, sizeof(*obj));
2129     if(!obj)
2130     {
2131         ERR("No memory.\n");
2132         return;
2133     }
2134
2135     obj->IWineMSHTMLConsole_iface.lpVtbl = &WineMSHTMLConsoleVtbl;
2136     init_dispatch(&obj->dispex, &console_dispex, window, dispex_compat_mode(&window->event_target.dispex));
2137
2138     *ret = &obj->IWineMSHTMLConsole_iface;
2139 }
2140
2141 struct media_query_list_listener {
2142     struct list entry;
2143     IDispatch *function;
2144 };
2145
2146 struct media_query_list_callback;
2147 struct media_query_list {
2148     DispatchEx dispex;
2149     IWineMSHTMLMediaQueryList IWineMSHTMLMediaQueryList_iface;
2150     nsIDOMMediaQueryList *nsquerylist;
2151     struct media_query_list_callback *callback;
2152     struct list listeners;
2153 };
2154
2155 struct media_query_list_callback {
2156     nsIDOMMediaQueryListListener nsIDOMMediaQueryListListener_iface;
2157     struct media_query_list *media_query_list;
2158     LONG ref;
2159 };
2160
2161 static inline struct media_query_list *impl_from_IWineMSHTMLMediaQueryList(IWineMSHTMLMediaQueryList *iface)
2162 {
2163     return CONTAINING_RECORD(iface, struct media_query_list, IWineMSHTMLMediaQueryList_iface);
2164 }
2165
2166 DISPEX_IDISPATCH_IMPL(media_query_list, IWineMSHTMLMediaQueryList,
2167                       impl_from_IWineMSHTMLMediaQueryList(iface)->dispex)
2168
2169 static HRESULT WINAPI media_query_list_get_media(IWineMSHTMLMediaQueryList *iface, BSTR *p)
2170 {
2171     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2172     nsAString nsstr;
2173
2174     TRACE("(%p)->(%p)\n", media_query_list, p);
2175
2176     nsAString_InitDepend(&nsstr, NULL);
2177     return return_nsstr(nsIDOMMediaQueryList_GetMedia(media_query_list->nsquerylist, &nsstr), &nsstr, p);
2178 }
2179
2180 static HRESULT WINAPI media_query_list_get_matches(IWineMSHTMLMediaQueryList *iface, VARIANT_BOOL *p)
2181 {
2182     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2183     nsresult nsres;
2184     cpp_bool b;
2185
2186     TRACE("(%p)->(%p)\n", media_query_list, p);
2187
2188     nsres = nsIDOMMediaQueryList_GetMatches(media_query_list->nsquerylist, &b);
2189     if(NS_FAILED(nsres))
2190         return map_nsresult(nsres);
2191     *p = b ? VARIANT_TRUE : VARIANT_FALSE;
2192     return S_OK;
2193 }
2194
2195 static HRESULT WINAPI media_query_list_addListener(IWineMSHTMLMediaQueryList *iface, VARIANT *listener)
2196 {
2197     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2198     struct media_query_list_listener *entry;
2199
2200     TRACE("(%p)->(%s)\n", media_query_list, debugstr_variant(listener));
2201
2202     if(V_VT(listener) != VT_DISPATCH || !V_DISPATCH(listener))
2203         return S_OK;
2204
2205     LIST_FOR_EACH_ENTRY(entry, &media_query_list->listeners, struct media_query_list_listener, entry)
2206         if(entry->function == V_DISPATCH(listener))
2207             return S_OK;
2208
2209     if(!(entry = malloc(sizeof(*entry))))
2210         return E_OUTOFMEMORY;
2211     entry->function = V_DISPATCH(listener);
2212     IDispatch_AddRef(V_DISPATCH(listener));
2213
2214     list_add_tail(&media_query_list->listeners, &entry->entry);
2215     return S_OK;
2216 }
2217
2218 static HRESULT WINAPI media_query_list_removeListener(IWineMSHTMLMediaQueryList *iface, VARIANT *listener)
2219 {
2220     struct media_query_list *media_query_list = impl_from_IWineMSHTMLMediaQueryList(iface);
2221     struct media_query_list_listener *entry;
2222
2223     TRACE("(%p)->(%s)\n", media_query_list, debugstr_variant(listener));
2224
2225     if(V_VT(listener) != VT_DISPATCH || !V_DISPATCH(listener))
2226         return S_OK;
2227
2228     LIST_FOR_EACH_ENTRY(entry, &media_query_list->listeners, struct media_query_list_listener, entry) {
2229         if(entry->function == V_DISPATCH(listener)) {
2230             list_remove(&entry->entry);
2231             IDispatch_Release(entry->function);
2232             free(entry);
2233             break;
2234         }
2235     }
2236
2237     return S_OK;
2238 }
2239
2240 static const IWineMSHTMLMediaQueryListVtbl media_query_list_vtbl = {
2241     media_query_list_QueryInterface,
2242     media_query_list_AddRef,
2243     media_query_list_Release,
2244     media_query_list_GetTypeInfoCount,
2245     media_query_list_GetTypeInfo,
2246     media_query_list_GetIDsOfNames,
2247     media_query_list_Invoke,
2248     media_query_list_get_media,
2249     media_query_list_get_matches,
2250     media_query_list_addListener,
2251     media_query_list_removeListener
2252 };
2253
2254 static inline struct media_query_list_callback *impl_from_nsIDOMMediaQueryListListener(nsIDOMMediaQueryListListener *iface)
2255 {
2256     return CONTAINING_RECORD(iface, struct media_query_list_callback, nsIDOMMediaQueryListListener_iface);
2257 }
2258
2259 static nsresult NSAPI media_query_list_callback_QueryInterface(nsIDOMMediaQueryListListener *iface,
2260         nsIIDRef riid, void **result)
2261 {
2262     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2263
2264     if(IsEqualGUID(&IID_nsISupports, riid) || IsEqualGUID(&IID_nsIDOMMediaQueryListListener, riid)) {
2265         *result = &callback->nsIDOMMediaQueryListListener_iface;
2266     }else {
2267         *result = NULL;
2268         return NS_NOINTERFACE;
2269     }
2270
2271     nsIDOMMediaQueryListListener_AddRef(&callback->nsIDOMMediaQueryListListener_iface);
2272     return NS_OK;
2273 }
2274
2275 static nsrefcnt NSAPI media_query_list_callback_AddRef(nsIDOMMediaQueryListListener *iface)
2276 {
2277     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2278     LONG ref = InterlockedIncrement(&callback->ref);
2279
2280     TRACE("(%p) ref=%ld\n", callback, ref);
2281
2282     return ref;
2283 }
2284
2285 static nsrefcnt NSAPI media_query_list_callback_Release(nsIDOMMediaQueryListListener *iface)
2286 {
2287     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2288     LONG ref = InterlockedDecrement(&callback->ref);
2289
2290     TRACE("(%p) ref=%ld\n", callback, ref);
2291
2292     if(!ref)
2293         free(callback);
2294     return ref;
2295 }
2296
2297 static nsresult NSAPI media_query_list_callback_HandleChange(nsIDOMMediaQueryListListener *iface, nsIDOMMediaQueryList *mql)
2298 {
2299     struct media_query_list_callback *callback = impl_from_nsIDOMMediaQueryListListener(iface);
2300     IDispatch *listener_funcs_buf[4], **listener_funcs = listener_funcs_buf;
2301     struct media_query_list *media_query_list = callback->media_query_list;
2302     struct media_query_list_listener *listener;
2303     unsigned cnt, i = 0;
2304     VARIANT args[1], v;
2305     HRESULT hres;
2306
2307     if(!media_query_list)
2308         return NS_OK;
2309
2310     cnt = list_count(&media_query_list->listeners);
2311     if(cnt > ARRAY_SIZE(listener_funcs_buf) && !(listener_funcs = malloc(cnt * sizeof(*listener_funcs))))
2312         return NS_ERROR_OUT_OF_MEMORY;
2313
2314     LIST_FOR_EACH_ENTRY(listener, &media_query_list->listeners, struct media_query_list_listener, entry) {
2315         listener_funcs[i] = listener->function;
2316         IDispatch_AddRef(listener_funcs[i++]);
2317     }
2318
2319     for(i = 0; i < cnt; i++) {
2320         DISPPARAMS dp = { args, NULL, 1, 0 };
2321
2322         V_VT(args) = VT_DISPATCH;
2323         V_DISPATCH(args) = (IDispatch*)&media_query_list->dispex.IWineJSDispatchHost_iface;
2324         V_VT(&v) = VT_EMPTY;
2325
2326         TRACE("%p >>>\n", media_query_list);
2327         hres = call_disp_func(listener_funcs[i], &dp, &v);
2328         if(hres == S_OK) {
2329             TRACE("%p <<< %s\n", media_query_list, debugstr_variant(&v));
2330             VariantClear(&v);
2331         }else {
2332             WARN("%p <<< %08lx\n", media_query_list, hres);
2333         }
2334         IDispatch_Release(listener_funcs[i]);
2335     }
2336
2337     if(listener_funcs != listener_funcs_buf)
2338         free(listener_funcs);
2339     return NS_OK;
2340 }
2341
2342 static const nsIDOMMediaQueryListListenerVtbl media_query_list_callback_vtbl = {
2343     media_query_list_callback_QueryInterface,
2344     media_query_list_callback_AddRef,
2345     media_query_list_callback_Release,
2346     media_query_list_callback_HandleChange
2347 };
2348
2349 static inline struct media_query_list *media_query_list_from_DispatchEx(DispatchEx *iface)
2350 {
2351     return CONTAINING_RECORD(iface, struct media_query_list, dispex);
2352 }
2353
2354 static void *media_query_list_query_interface(DispatchEx *dispex, REFIID riid)
2355 {
2356     struct media_query_list *media_query_list = media_query_list_from_DispatchEx(dispex);
2357
2358     if(IsEqualGUID(&IID_IWineMSHTMLMediaQueryList, riid))
2359         return &media_query_list->IWineMSHTMLMediaQueryList_iface;
2360
2361     return NULL;
2362 }
2363
2364 static void media_query_list_traverse(DispatchEx *dispex, nsCycleCollectionTraversalCallback *cb)
2365 {
2366     struct media_query_list *media_query_list = media_query_list_from_DispatchEx(dispex);
2367     struct media_query_list_listener *listener;
2368
2369     LIST_FOR_EACH_ENTRY(listener, &media_query_list->listeners, struct media_query_list_listener, entry)
2370         note_cc_edge((nsISupports*)listener->function, "function", cb);
2371     if(media_query_list->nsquerylist)
2372         note_cc_edge((nsISupports*)media_query_list->nsquerylist, "nsquerylist", cb);
2373 }
2374
2375 static void media_query_list_unlink(DispatchEx *dispex)
2376 {
2377     struct media_query_list *media_query_list = media_query_list_from_DispatchEx(dispex);
2378
2379     media_query_list->callback->media_query_list = NULL;
2380     while(!list_empty(&media_query_list->listeners)) {
2381         struct media_query_list_listener *listener = LIST_ENTRY(list_head(&media_query_list->listeners), struct media_query_list_listener, entry);
2382         list_remove(&listener->entry);
2383         IDispatch_Release(listener->function);
2384         free(listener);
2385     }
2386     unlink_ref(&media_query_list->nsquerylist);
2387 }
2388
2389 static void media_query_list_destructor(DispatchEx *dispex)
2390 {
2391     struct media_query_list *media_query_list = media_query_list_from_DispatchEx(dispex);
2392     nsIDOMMediaQueryListListener_Release(&media_query_list->callback->nsIDOMMediaQueryListListener_iface);
2393     free(media_query_list);
2394 }
2395
2396 static const dispex_static_data_vtbl_t media_query_list_dispex_vtbl = {
2397     .query_interface  = media_query_list_query_interface,
2398     .destructor       = media_query_list_destructor,
2399     .traverse         = media_query_list_traverse,
2400     .unlink           = media_query_list_unlink
2401 };
2402
2403 static const tid_t media_query_list_iface_tids[] = {
2404     IWineMSHTMLMediaQueryList_tid,
2405     0
2406 };
2407 static dispex_static_data_t media_query_list_dispex = {
2408     "MediaQueryList",
2409     &media_query_list_dispex_vtbl,
2410     IWineMSHTMLMediaQueryList_tid,
2411     media_query_list_iface_tids
2412 };
2413
2414 HRESULT create_media_query_list(HTMLInnerWindow *window, BSTR media_query, IDispatch **ret)
2415 {
2416     struct media_query_list *media_query_list;
2417     nsISupports *nsunk;
2418     nsAString nsstr;
2419     nsresult nsres;
2420
2421     if(!media_query || !media_query[0])
2422         return E_INVALIDARG;
2423
2424     if(!(media_query_list = malloc(sizeof(*media_query_list))))
2425         return E_OUTOFMEMORY;
2426
2427     if(!(media_query_list->callback = malloc(sizeof(*media_query_list->callback)))) {
2428         free(media_query_list);
2429         return E_OUTOFMEMORY;
2430     }
2431     media_query_list->callback->nsIDOMMediaQueryListListener_iface.lpVtbl = &media_query_list_callback_vtbl;
2432     media_query_list->callback->media_query_list = media_query_list;
2433     media_query_list->callback->ref = 1;
2434
2435     nsAString_InitDepend(&nsstr, media_query);
2436     nsres = nsIDOMWindow_MatchMedia(window->dom_window, &nsstr, &nsunk);
2437     nsAString_Finish(&nsstr);
2438     if(NS_FAILED(nsres)) {
2439         free(media_query_list->callback);
2440         free(media_query_list);
2441         return map_nsresult(nsres);
2442     }
2443     nsres = nsISupports_QueryInterface(nsunk, &IID_nsIDOMMediaQueryList, (void**)&media_query_list->nsquerylist);
2444     assert(NS_SUCCEEDED(nsres));
2445     nsISupports_Release(nsunk);
2446
2447     nsres = nsIDOMMediaQueryList_SetListener(media_query_list->nsquerylist, &media_query_list->callback->nsIDOMMediaQueryListListener_iface);
2448     assert(NS_SUCCEEDED(nsres));
2449
2450     media_query_list->IWineMSHTMLMediaQueryList_iface.lpVtbl = &media_query_list_vtbl;
2451     list_init(&media_query_list->listeners);
2452     init_dispatch(&media_query_list->dispex, &media_query_list_dispex, window,
2453                   dispex_compat_mode(&window->event_target.dispex));
2454
2455     *ret = (IDispatch*)&media_query_list->IWineMSHTMLMediaQueryList_iface;
2456     return S_OK;
2457 }